testgres 1.13.7__tar.gz → 1.14.1__tar.gz

{testgres-1.13.7/testgres.egg-info → testgres-1.14.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres
-Version: 1.13.7
+Version: 1.14.1
 Summary: Testing utility for PostgreSQL and its extensions
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL
@@ -27,11 +27,10 @@ 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.1.0
+Requires-Dist: testgres.os_ops<3.0.0,>=2.3.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)
-[![codecov](https://codecov.io/gh/postgrespro/testgres/branch/master/graph/badge.svg)](https://codecov.io/gh/postgrespro/testgres)
+[![CI Status](https://img.shields.io/github/actions/workflow/status/postgrespro/testgres/.github/workflows/ci.yml?label=CI)](https://github.com/postgrespro/testgres/actions/workflows/ci.yml)
 [![PyPI package version](https://badge.fury.io/py/testgres.svg)](https://badge.fury.io/py/testgres)
 [![PyPI python versions](https://img.shields.io/pypi/pyversions/testgres)](https://pypi.org/project/testgres)
 [![PyPI downloads](https://img.shields.io/pypi/dm/testgres)](https://pypi.org/project/testgres)

{testgres-1.13.7 → testgres-1.14.1}/README.md

@@ -1,5 +1,4 @@
-[![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)
-[![codecov](https://codecov.io/gh/postgrespro/testgres/branch/master/graph/badge.svg)](https://codecov.io/gh/postgrespro/testgres)
+[![CI Status](https://img.shields.io/github/actions/workflow/status/postgrespro/testgres/.github/workflows/ci.yml?label=CI)](https://github.com/postgrespro/testgres/actions/workflows/ci.yml)
 [![PyPI package version](https://badge.fury.io/py/testgres.svg)](https://badge.fury.io/py/testgres)
 [![PyPI python versions](https://img.shields.io/pypi/pyversions/testgres)](https://pypi.org/project/testgres)
 [![PyPI downloads](https://img.shields.io/pypi/dm/testgres)](https://pypi.org/project/testgres)

{testgres-1.13.7 → testgres-1.14.1}/pyproject.toml

@@ -65,7 +65,7 @@ dependencies = [
     "six>=1.9.0",
     "psutil",
     "packaging",
-    "testgres.os_ops>=2.1.0,<3.0.0",
+    "testgres.os_ops>=2.3.0,<3.0.0",
 ]
 
 [project.urls]

{testgres-1.13.7 → testgres-1.14.1}/src/__init__.py

@@ -56,7 +56,7 @@ from testgres.operations.os_ops import OsOperations, ConnectionParams
 from testgres.operations.local_ops import LocalOperations
 from testgres.operations.remote_ops import RemoteOperations
 
-__version__ = "1.13.7"
+__version__ = "1.14.1"
 
 __all__ = [
     "get_new_node",
@@ -65,12 +65,12 @@ __all__ = [
     "TestgresConfig", "configure_testgres", "scoped_config", "push_config", "pop_config",
     "NodeConnection", "DatabaseError", "InternalError", "ProgrammingError", "OperationalError",
     "TestgresException", "ExecUtilException", "QueryException",
-    QueryTimeoutException.__name__,
+    "QueryTimeoutException",
     "TimeoutException", "CatchUpException", "StartNodeException", "InitNodeException", "BackupException", "InvalidOperationException",
     "XLogMethod", "IsolationLevel", "NodeStatus", "ProcessType", "DumpFormat",
-    NodeApp.__name__,
-    PostgresNode.__name__,
-    PortManager.__name__,
+    "NodeApp",
+    "PostgresNode",
+    "PortManager",
     "reserve_port", "release_port", "bound_ports", "get_bin_path", "get_pg_config", "get_pg_version",
     "First", "Any",
     "OsOperations", "LocalOperations", "RemoteOperations", "ConnectionParams"

{testgres-1.13.7 → testgres-1.14.1}/src/api.py

@@ -31,6 +31,10 @@ PostgresNode(name='...', port=..., base_dir='...')
 [(3,)]
 """
 from .node import PostgresNode
+from testgres.operations.remote_ops import ConnectionParams
+from testgres.operations.remote_ops import RemoteOperations
+
+import typing
 
 
 def get_new_node(name=None, base_dir=None, **kwargs):
@@ -42,11 +46,16 @@ def get_new_node(name=None, base_dir=None, **kwargs):
     return PostgresNode(name=name, base_dir=base_dir, **kwargs)
 
 
-def get_remote_node(name=None, conn_params=None):
+def get_remote_node(name=None, conn_params: typing.Optional[ConnectionParams] = None):
     """
     Simply a wrapper around :class:`.PostgresNode` constructor for remote node.
     See :meth:`.PostgresNode.__init__` for details.
     For remote connection you can add the next parameter:
     conn_params = ConnectionParams(host='127.0.0.1', ssh_key=None, username=default_username())
     """
-    return get_new_node(name=name, conn_params=conn_params)
+
+    if conn_params is None:
+        raise ValueError("Argument 'conn_params' is None.")
+
+    os_ops = RemoteOperations(conn_params)
+    return PostgresNode(name=name, os_ops=os_ops)

{testgres-1.13.7 → testgres-1.14.1}/src/backup.py

@@ -152,12 +152,7 @@ class NodeBackup(object):
         # Build a new PostgresNode
         assert self.original_node is not None
 
-        if (hasattr(self.original_node, "clone_with_new_name_and_base_dir")):
-            node = self.original_node.clone_with_new_name_and_base_dir(name=name, base_dir=base_dir)
-        else:
-            # For backward compatibility
-            NodeClass = self.original_node.__class__
-            node = NodeClass(name=name, base_dir=base_dir, conn_params=self.original_node.os_ops.conn_params)
+        node = self.original_node.clone_with_new_name_and_base_dir(name=name, base_dir=base_dir)
 
         assert node is not None
         assert type(node) is self.original_node.__class__

{testgres-1.13.7 → testgres-1.14.1}/src/node.py

@@ -2,7 +2,6 @@
 from __future__ import annotations
 
 import logging
-import os
 import signal
 import subprocess
 
@@ -91,7 +90,6 @@ from . import utils
 from .utils import \
     PgVer, \
     eprint, \
-    get_bin_path2, \
     get_pg_version2, \
     execute_utility2, \
     options_string, \
@@ -101,7 +99,6 @@ from .raise_error import RaiseError
 
 from .backup import NodeBackup
 
-from testgres.operations.os_ops import ConnectionParams
 from testgres.operations.os_ops import OsOperations
 from testgres.operations.local_ops import LocalOperations
 
@@ -164,21 +161,25 @@ class PostgresNode(object):
     _C_PM_PID__IS_NOT_DETECTED = -1
 
     _name: typing.Optional[str]
+    _host: str
     _port: typing.Optional[int]
+    _bin_dir: str
     _should_free_port: bool
     _os_ops: OsOperations
     _port_manager: typing.Optional[PortManager]
     _manually_started_pm_pid: typing.Optional[int]
 
-    def __init__(self,
-                 name=None,
-                 base_dir=None,
-                 port: typing.Optional[int] = None,
-                 conn_params: typing.Optional[ConnectionParams] = None,
-                 bin_dir=None,
-                 prefix=None,
-                 os_ops: typing.Optional[OsOperations] = None,
-                 port_manager: typing.Optional[PortManager] = None):
+    def __init__(
+        self,
+        name=None,
+        base_dir=None,
+        port: typing.Optional[int] = None,
+        bin_dir: typing.Optional[str] = None,
+        prefix=None,
+        os_ops: typing.Optional[OsOperations] = None,
+        port_manager: typing.Optional[PortManager] = None,
+        host: typing.Optional[str] = None,
+    ):
         """
         PostgresNode constructor.
 
@@ -189,15 +190,13 @@ class PostgresNode(object):
             bin_dir: path to node's binary directory.
             os_ops: None or correct OS operation object.
             port_manager: None or correct port manager object.
+            host: None or valid address of node host.
         """
         assert port is None or type(port) is int
+        assert bin_dir is None or type(bin_dir) is str
         assert os_ops is None or isinstance(os_ops, OsOperations)
         assert port_manager is None or isinstance(port_manager, PortManager)
-
-        if conn_params is not None:
-            assert type(conn_params) is ConnectionParams
-
-            raise InvalidOperationException("conn_params is deprecated, please use os_ops parameter instead.")
+        assert host is None or type(host) is str
 
         # private
         if os_ops is None:
@@ -210,9 +209,15 @@ class PostgresNode(object):
         assert self._os_ops is not None
         assert isinstance(self._os_ops, OsOperations)
 
-        self._pg_version = PgVer(get_pg_version2(self._os_ops, bin_dir))
+        if bin_dir is not None:
+            self._bin_dir = bin_dir
+        else:
+            self._bin_dir = utils.get_bin_dir(self._os_ops)
+
+        assert type(self._bin_dir) is str
+
+        self._pg_version = PgVer(get_pg_version2(self._os_ops, self._bin_dir))
         self._base_dir = base_dir
-        self._bin_dir = bin_dir
         self._prefix = prefix
         self._logger = None
         self._master = None
@@ -220,6 +225,16 @@ class PostgresNode(object):
         # basic
         self._name = name or generate_app_name()
 
+        if host is not None:
+            assert type(host) is str
+            self._host = host
+        else:
+            self._host = self._os_ops.host
+            assert type(self._host) is str
+
+        if self._host == "":
+            raise RuntimeError("PostgresNode host is empty.")
+
         if port is not None:
             assert type(port) is int
             assert port_manager is None
@@ -250,10 +265,6 @@ class PostgresNode(object):
         self.cleanup_on_bad_exit = testgres_config.node_cleanup_on_bad_exit
         self.shutdown_max_attempts = 3
 
-        # NOTE: for compatibility
-        self.utils_log_name = self.utils_log_file
-        self.pg_log_name = self.pg_log_file
-
         # Node state
         self._manually_started_pm_pid = None
 
@@ -318,6 +329,7 @@ class PostgresNode(object):
         assert isinstance(self._port_manager, PortManager)
         assert self._os_ops is not None
         assert isinstance(self._os_ops, OsOperations)
+        assert type(self._host) is str
 
         node = PostgresNode(
             name=name,
@@ -325,7 +337,9 @@ class PostgresNode(object):
             bin_dir=self._bin_dir,
             prefix=self._prefix,
             os_ops=self._os_ops,
-            port_manager=self._port_manager)
+            port_manager=self._port_manager,
+            host=self._host,
+        )
 
         return node
 
@@ -349,9 +363,9 @@ class PostgresNode(object):
 
     @property
     def host(self) -> str:
-        assert self._os_ops is not None
-        assert isinstance(self._os_ops, OsOperations)
-        return self._os_ops.host
+        assert self._host is not None
+        assert type(self._host) is str
+        return self._host
 
     @property
     def port(self) -> int:
@@ -468,7 +482,7 @@ class PostgresNode(object):
         assert type(self.master) is PostgresNode
 
         # master should be on the same host
-        assert self.master.host == self.host
+        assert self.master.host == self._host
 
         with self.master.connect() as con:
             for row in con.execute(sql, self.name):
@@ -486,18 +500,17 @@ class PostgresNode(object):
     @property
     def base_dir(self):
         if not self._base_dir:
-            self._base_dir = self.os_ops.mkdtemp(prefix=self._prefix or TMP_NODE)
+            self._base_dir = self._os_ops.mkdtemp(prefix=self._prefix or TMP_NODE)
 
         # NOTE: it's safe to create a new dir
-        if not self.os_ops.path_exists(self._base_dir):
-            self.os_ops.makedirs(self._base_dir)
+        if not self._os_ops.path_exists(self._base_dir):
+            self._os_ops.makedirs(self._base_dir)
 
         return self._base_dir
 
     @property
-    def bin_dir(self):
-        if not self._bin_dir:
-            self._bin_dir = os.path.dirname(get_bin_path2(self.os_ops, "pg_config"))
+    def bin_dir(self) -> str:
+        assert type(self._bin_dir) is str
         return self._bin_dir
 
     @property
@@ -509,8 +522,8 @@ class PostgresNode(object):
         assert type(path) is str
 
         # NOTE: it's safe to create a new dir
-        if not self.os_ops.path_exists(path):
-            self.os_ops.makedirs(path)
+        if not self._os_ops.path_exists(path):
+            self._os_ops.makedirs(path)
 
         return path
 
@@ -542,6 +555,16 @@ class PostgresNode(object):
         assert type(path) is str
         return path
 
+    # NOTE: for compatibility
+    @property
+    def utils_log_name(self) -> str:
+        return self.utils_log_file
+
+    # NOTE: for compatibility
+    @property
+    def pg_log_name(self) -> str:
+        return self.pg_log_file
+
     @property
     def version(self):
         """
@@ -587,7 +610,7 @@ class PostgresNode(object):
 
         ps_command = ['ps', '-o', 'pid=', '-p', str(node_pid)]
 
-        ps_output = self.os_ops.exec_command(cmd=ps_command, shell=True, ignore_errors=True).decode('utf-8')
+        ps_output = self._os_ops.exec_command(cmd=ps_command, shell=True, ignore_errors=True).decode('utf-8')
         assert type(ps_output) is str
 
         if ps_output == "":
@@ -600,13 +623,13 @@ class PostgresNode(object):
 
         try:
             eprint('Force stopping node {0} with PID {1}'.format(self.name, node_pid))
-            self.os_ops.kill(node_pid, signal.SIGKILL)
+            self._os_ops.kill(node_pid, signal.SIGKILL)
         except Exception:
             # The node has already stopped
             pass
 
         # Check that node stopped - print only column pid without headers
-        ps_output = self.os_ops.exec_command(cmd=ps_command, shell=True, ignore_errors=True).decode('utf-8')
+        ps_output = self._os_ops.exec_command(cmd=ps_command, shell=True, ignore_errors=True).decode('utf-8')
         assert type(ps_output) is str
 
         if ps_output == "":
@@ -669,7 +692,7 @@ class PostgresNode(object):
 
             signal_name = self._os_ops.build_path(self.data_dir, "standby.signal")
             assert type(signal_name) is str
-            self.os_ops.touch(signal_name)
+            self._os_ops.touch(signal_name)
         else:
             line += "standby_mode=on\n"
 
@@ -730,10 +753,10 @@ class PostgresNode(object):
 
         for f, num_lines in files:
             # skip missing files
-            if not self.os_ops.path_exists(f):
+            if not self._os_ops.path_exists(f):
                 continue
 
-            file_lines = self.os_ops.readlines(f, num_lines, binary=True, encoding=None)
+            file_lines = self._os_ops.readlines(f, num_lines, binary=True, encoding=None)
             lines = b''.join(file_lines)
 
             # fill list
@@ -800,14 +823,14 @@ class PostgresNode(object):
 
         # filter lines in hba file
         # get rid of comments and blank lines
-        hba_conf_file = self.os_ops.readlines(hba_conf)
+        hba_conf_file = self._os_ops.readlines(hba_conf)
         lines = [
             s for s in hba_conf_file
             if len(s.strip()) > 0 and not s.startswith('#')
         ]
 
         # write filtered lines
-        self.os_ops.write(hba_conf, lines, truncate=True)
+        self._os_ops.write(hba_conf, lines, truncate=True)
 
         # replication-related settings
         if allow_streaming:
@@ -819,7 +842,7 @@ class PostgresNode(object):
             # get auth methods
             auth_local = get_auth_method('local')
             auth_host = get_auth_method('host')
-            subnet_base = ".".join(self.os_ops.host.split('.')[:-1] + ['0'])
+            subnet_base = ".".join(self._os_ops.host.split('.')[:-1] + ['0'])
 
             new_lines = [
                 u"local\treplication\tall\t\t\t{}\n".format(auth_local),
@@ -832,15 +855,15 @@ class PostgresNode(object):
             ]  # yapf: disable
 
             # write missing lines
-            self.os_ops.write(hba_conf, new_lines)
+            self._os_ops.write(hba_conf, new_lines)
 
         # overwrite config file
-        self.os_ops.write(postgres_conf, '', truncate=True)
+        self._os_ops.write(postgres_conf, '', truncate=True)
 
         self.append_conf(fsync=fsync,
                          max_worker_processes=MAX_WORKER_PROCESSES,
                          log_statement=log_statement,
-                         listen_addresses=self.host,
+                         listen_addresses=self._host,
                          port=self.port)  # yapf:disable
 
         # common replication settings
@@ -915,7 +938,7 @@ class PostgresNode(object):
         conf_text = ''
         for line in lines:
             conf_text += text_type(line) + '\n'
-        self.os_ops.write(config_name, conf_text)
+        self._os_ops.write(config_name, conf_text)
 
         return self
 
@@ -931,6 +954,12 @@ class PostgresNode(object):
         return x.node_status
 
     def _get_node_state(self) -> utils.PostgresNodeState:
+        if self._base_dir is None:
+            return utils.PostgresNodeState(
+                node_status=NodeStatus.Uninitialized,
+                pid=None,
+            )
+
         return utils.get_pg_node_state(
             self._os_ops,
             self.bin_dir,
@@ -948,7 +977,7 @@ class PostgresNode(object):
         _params += ["-D"] if self._pg_version >= PgVer('9.5') else []
         _params += [self.data_dir]
 
-        data = execute_utility2(self.os_ops, _params, self.utils_log_file)
+        data = execute_utility2(self._os_ops, _params, self.utils_log_file)
 
         out_dict = {}
 
@@ -958,7 +987,14 @@ class PostgresNode(object):
 
         return out_dict
 
-    def slow_start(self, replica=False, dbname='template1', username=None, max_attempts=0, exec_env=None):
+    def slow_start(
+        self,
+        replica: bool = False,
+        dbname: typing.Optional[str] = 'template1',
+        username: typing.Optional[str] = None,
+        max_attempts: int = 0,
+        exec_env: typing.Optional[typing.Dict[str, str]] = None,
+    ):
         """
         Starts the PostgreSQL instance and then polls the instance
         until it reaches the expected state (primary or replica). The state is checked
@@ -971,6 +1007,8 @@ class PostgresNode(object):
                         If False, waits for the instance to be in primary mode. Default is False.
                max_attempts:
         """
+        assert dbname is None or type(dbname) is str
+        assert username is None or type(username) is str
         assert exec_env is None or type(exec_env) is dict
 
         self.start(exec_env=exec_env)
@@ -992,7 +1030,7 @@ class PostgresNode(object):
             self.poll_query_until(
                 query=query,
                 dbname=dbname,
-                username=username or self.os_ops.username,
+                username=username or self._os_ops.username,
                 suppress=suppressed_exceptions,
                 max_attempts=max_attempts,
             )
@@ -1094,7 +1132,7 @@ class PostgresNode(object):
 
         def LOCAL__start_node():
             # 'error' will be None on Windows
-            _, _, error = execute_utility2(self.os_ops, _params, self.utils_log_file, verbose=True, exec_env=exec_env)
+            _, _, error = execute_utility2(self._os_ops, _params, self.utils_log_file, verbose=True, exec_env=exec_env)
             assert error is None or type(error) is str
             if error and 'does not exist' in error:
                 raise Exception(error)
@@ -1183,7 +1221,7 @@ class PostgresNode(object):
             "stop"
         ] + params  # yapf: disable
 
-        execute_utility2(self.os_ops, _params, self.utils_log_file)
+        execute_utility2(self._os_ops, _params, self.utils_log_file)
 
         self._manually_started_pm_pid = None
 
@@ -1207,7 +1245,10 @@ class PostgresNode(object):
 
         assert x.node_status == NodeStatus.Running
         assert type(x.pid) is int
-        sig = signal.SIGKILL if os.name != 'nt' else signal.SIGBREAK
+        if self._os_ops.get_platform() == "win32":
+            sig = 21  # signal.SIGBREAK
+        else:
+            sig = signal.SIGKILL
         if someone is None:
             self._os_ops.kill(x.pid, sig)
             self._manually_started_pm_pid = None
@@ -1240,7 +1281,7 @@ class PostgresNode(object):
         ] + params  # yapf: disable
 
         try:
-            error_code, out, error = execute_utility2(self.os_ops, _params, self.utils_log_file, verbose=True)
+            error_code, out, error = execute_utility2(self._os_ops, _params, self.utils_log_file, verbose=True)
             if error and 'could not start server' in error:
                 raise ExecUtilException
         except ExecUtilException as e:
@@ -1269,7 +1310,7 @@ class PostgresNode(object):
             "reload"
         ] + params  # yapf: disable
 
-        execute_utility2(self.os_ops, _params, self.utils_log_file)
+        execute_utility2(self._os_ops, _params, self.utils_log_file)
 
         return self
 
@@ -1291,7 +1332,7 @@ class PostgresNode(object):
             "promote"
         ]  # yapf: disable
 
-        execute_utility2(self.os_ops, _params, self.utils_log_file)
+        execute_utility2(self._os_ops, _params, self.utils_log_file)
 
         # for versions below 10 `promote` is asynchronous so we need to wait
         # until it actually becomes writable
@@ -1326,7 +1367,7 @@ class PostgresNode(object):
             "-w"  # wait
         ] + params  # yapf: disable
 
-        return execute_utility2(self.os_ops, _params, self.utils_log_file)
+        return execute_utility2(self._os_ops, _params, self.utils_log_file)
 
     def release_resources(self):
         """
@@ -1362,7 +1403,7 @@ class PostgresNode(object):
         else:
             rm_dir = self.data_dir    # just data, save logs
 
-        self.os_ops.rmdirs(rm_dir, ignore_errors=False)
+        self._os_ops.rmdirs(rm_dir, ignore_errors=False)
 
         if release_resources:
             self._release_resources()
@@ -1443,7 +1484,7 @@ class PostgresNode(object):
             raise Exception("Input data must be None or bytes.")
 
         if host is None:
-            host = self.host
+            host = self._host
 
         if port is None:
             port = self.port
@@ -1457,7 +1498,7 @@ class PostgresNode(object):
             self._get_bin_path("psql"),
             "-p", str(port),
             "-h", host,
-            "-U", username or self.os_ops.username,
+            "-U", username or self._os_ops.username,
             "-d", dbname or default_dbname(),
             "-X",  # no .psqlrc
             "-A",  # unaligned output
@@ -1477,7 +1518,7 @@ class PostgresNode(object):
         else:
             raise QueryException('Query or filename must be provided')
 
-        return self.os_ops.exec_command(
+        return self._os_ops.exec_command(
             psql_params,
             verbose=True,
             input=input,
@@ -1560,9 +1601,9 @@ class PostgresNode(object):
         # Generate tmpfile or tmpdir
         def tmpfile():
             if format == DumpFormat.Directory:
-                fname = self.os_ops.mkdtemp(prefix=TMP_DUMP)
+                fname = self._os_ops.mkdtemp(prefix=TMP_DUMP)
             else:
-                fname = self.os_ops.mkstemp(prefix=TMP_DUMP)
+                fname = self._os_ops.mkstemp(prefix=TMP_DUMP)
             return fname
 
         filename = filename or tmpfile()
@@ -1570,9 +1611,9 @@ class PostgresNode(object):
         _params = [
             self._get_bin_path("pg_dump"),
             "-p", str(self.port),
-            "-h", self.host,
+            "-h", self._host,
             "-f", filename,
-            "-U", username or self.os_ops.username,
+            "-U", username or self._os_ops.username,
             "-d", dbname or default_dbname(),
             "-F", format.value
         ]  # yapf: disable
@@ -1581,7 +1622,7 @@ class PostgresNode(object):
         if options:
             _params.extend(options)
 
-        execute_utility2(self.os_ops, _params, self.utils_log_file)
+        execute_utility2(self._os_ops, _params, self.utils_log_file)
 
         return filename
 
@@ -1597,12 +1638,12 @@ class PostgresNode(object):
 
         # Set default arguments
         dbname = dbname or default_dbname()
-        username = username or self.os_ops.username
+        username = username or self._os_ops.username
 
         _params = [
             self._get_bin_path("pg_restore"),
             "-p", str(self.port),
-            "-h", self.host,
+            "-h", self._host,
             "-U", username,
             "-d", dbname,
             filename
@@ -1610,20 +1651,22 @@ class PostgresNode(object):
 
         # try pg_restore if dump is binary format, and psql if not
         try:
-            execute_utility2(self.os_ops, _params, self.utils_log_name)
+            execute_utility2(self._os_ops, _params, self.utils_log_file)
         except ExecUtilException:
             self.psql(filename=filename, dbname=dbname, username=username)
 
     @method_decorator(positional_args_hack(['dbname', 'query']))
-    def poll_query_until(self,
-                         query,
-                         dbname=None,
-                         username=None,
-                         max_attempts=0,
-                         sleep_time: typing.Union[int, float] = 1,
-                         expected=True,
-                         commit=True,
-                         suppress=None):
+    def poll_query_until(
+        self,
+        query,
+        dbname: typing.Optional[str] = None,
+        username: typing.Optional[str] = None,
+        max_attempts: int = 0,
+        sleep_time: typing.Union[int, float] = 1,
+        expected: bool = True,
+        commit: bool = True,
+        suppress: typing.Optional[typing.Iterable[BaseException]] = None,
+    ) -> None:
         """
         Run a query once per second until it returns 'expected'.
         Query should return a single value (1 row, 1 column).
@@ -1650,6 +1693,8 @@ class PostgresNode(object):
         assert max_attempts >= 0
         assert type(sleep_time) in [int, float]
         assert sleep_time > 0
+        assert suppress is None or isinstance(suppress, typing.Iterable)
+
         attempts = 0
         while max_attempts == 0 or attempts < max_attempts:
             try:
@@ -1874,14 +1919,14 @@ class PostgresNode(object):
         _params = [
             self._get_bin_path("pgbench"),
             "-p", str(self.port),
-            "-h", self.host,
-            "-U", username or self.os_ops.username
+            "-h", self._host,
+            "-U", username or self._os_ops.username
         ] + options  # yapf: disable
 
         # should be the last one
         _params.append(dbname)
 
-        proc = self.os_ops.exec_command(_params, stdout=stdout, stderr=stderr, wait_exit=True, get_process=True)
+        proc = self._os_ops.exec_command(_params, stdout=stdout, stderr=stderr, wait_exit=True, get_process=True)
 
         return proc
 
@@ -1947,8 +1992,8 @@ class PostgresNode(object):
         _params = [
             self._get_bin_path("pgbench"),
             "-p", str(self.port),
-            "-h", self.host,
-            "-U", username or self.os_ops.username
+            "-h", self._host,
+            "-U", username or self._os_ops.username
         ] + options  # yapf: disable
 
         for key, value in iteritems(kwargs):
@@ -1965,7 +2010,7 @@ class PostgresNode(object):
         # should be the last one
         _params.append(dbname)
 
-        return execute_utility2(self.os_ops, _params, self.utils_log_file)
+        return execute_utility2(self._os_ops, _params, self.utils_log_file)
 
     def connect(self,
                 dbname=None,
@@ -2054,9 +2099,9 @@ class PostgresNode(object):
         assert isinstance(self._os_ops, OsOperations)
 
         # parse postgresql.auto.conf
-        path = self.os_ops.build_path(self.data_dir, config)
+        path = self._os_ops.build_path(self.data_dir, config)
 
-        lines = self.os_ops.readlines(path)
+        lines = self._os_ops.readlines(path)
         current_options = {}
         current_directives = []
         for line in lines:
@@ -2103,7 +2148,7 @@ class PostgresNode(object):
         for directive in current_directives:
             auto_conf += directive + "\n"
 
-        self.os_ops.write(path, auto_conf, truncate=True)
+        self._os_ops.write(path, auto_conf, truncate=True)
 
     def upgrade_from(self, old_node, options=None, expect_error=False):
         """
@@ -2138,7 +2183,7 @@ class PostgresNode(object):
         ]
         upgrade_command += options
 
-        return self.os_ops.exec_command(upgrade_command, expect_error=expect_error)
+        return self._os_ops.exec_command(upgrade_command, expect_error=expect_error)
 
     def _release_resources(self):
         self._free_port()
@@ -2162,12 +2207,9 @@ class PostgresNode(object):
     def _get_bin_path(self, filename):
         assert self._os_ops is not None
         assert isinstance(self._os_ops, OsOperations)
+        assert type(self._bin_dir) is str
 
-        if self.bin_dir:
-            bin_path = self._os_ops.build_path(self.bin_dir, filename)
-        else:
-            bin_path = get_bin_path2(self.os_ops, filename)
-        return bin_path
+        return self._os_ops.build_path(self._bin_dir, filename)
 
     @staticmethod
     def _escape_config_value(value):

{testgres-1.13.7 → testgres-1.14.1}/src/node_app.py

@@ -3,9 +3,6 @@ from .node import LocalOperations
 from .node import PostgresNode
 from .node import PortManager
 
-import os
-import platform
-import tempfile
 import typing
 
 
@@ -16,7 +13,7 @@ T_LIST_STR = typing.List[str]
 class NodeApp:
     _test_path: str
     _os_ops: OsOperations
-    _port_manager: PortManager
+    _port_manager: typing.Optional[PortManager]
     _nodes_to_cleanup: typing.List[PostgresNode]
 
     def __init__(
@@ -39,7 +36,7 @@ class NodeApp:
 
         if test_path is None:
             self._test_path = os_ops.cwd()
-        elif os.path.isabs(test_path):
+        elif self._os_ops.is_abs_path(test_path):
             self._test_path = test_path
         else:
             self._test_path = os_ops.build_path(os_ops.cwd(), test_path)
@@ -60,7 +57,7 @@ class NodeApp:
         return self._os_ops
 
     @property
-    def port_manager(self) -> PortManager:
+    def port_manager(self) -> typing.Optional[PortManager]:
         assert self._port_manager is None or isinstance(self._port_manager, PortManager)
         return self._port_manager
 
@@ -158,6 +155,8 @@ class NodeApp:
 
         # set major version
         pg_version_file = self._os_ops.read(self._os_ops.build_path(node.data_dir, 'PG_VERSION'))
+
+        # What is it ???
         node.major_version_str = str(pg_version_file.rstrip())
         node.major_version = float(node.major_version_str)
 
@@ -200,7 +199,7 @@ class NodeApp:
 
         # Define delayed propertyes
         if "unix_socket_directories" not in options.keys():
-            options["unix_socket_directories"] = __class__._gettempdir_for_socket()
+            options["unix_socket_directories"] = self._gettempdir_for_socket()
 
         # Set config values
         node.set_auto_conf(options)
@@ -260,49 +259,50 @@ class NodeApp:
             return updated_params
         return __class__._paramlist_append(user_params, updated_params, param)
 
-    @staticmethod
-    def _gettempdir_for_socket() -> str:
-        platform_system_name = platform.system().lower()
-
-        if platform_system_name == "windows":
-            return __class__._gettempdir()
-
-        #
-        # [2025-02-17] Hot fix.
-        #
-        # Let's use hard coded path as Postgres likes.
-        #
-        # pg_config_manual.h:
-        #
-        # #ifndef WIN32
-        # #define DEFAULT_PGSOCKET_DIR  "/tmp"
-        # #else
-        # #define DEFAULT_PGSOCKET_DIR ""
-        # #endif
-        #
-        # On the altlinux-10 tempfile.gettempdir() may return
-        # the path to "private" temp directiry - "/temp/.private/<username>/"
-        #
-        # But Postgres want to find a socket file in "/tmp" (see above).
-        #
+    def _gettempdir_for_socket(self) -> str:
+        assert isinstance(self._os_ops, OsOperations)
 
-        return "/tmp"
+        platform_name = self._os_ops.get_platform()
+
+        if platform_name == "linux":
+            #
+            # [2025-02-17] Hot fix.
+            #
+            # Let's use hard coded path as Postgres likes.
+            #
+            # pg_config_manual.h:
+            #
+            # #ifndef WIN32
+            # #define DEFAULT_PGSOCKET_DIR  "/tmp"
+            # #else
+            # #define DEFAULT_PGSOCKET_DIR ""
+            # #endif
+            #
+            # On the altlinux-10 tempfile.gettempdir() may return
+            # the path to "private" temp directiry - "/temp/.private/<username>/"
+            #
+            # But Postgres want to find a socket file in "/tmp" (see above).
+            #
+            return "/tmp"
+
+        return self._gettempdir()
+
+    def _gettempdir(self) -> str:
+        assert isinstance(self._os_ops, OsOperations)
 
-    @staticmethod
-    def _gettempdir() -> str:
-        v = tempfile.gettempdir()
+        v = self._os_ops.get_tempdir()
 
         #
         # Paranoid checks
         #
         if type(v) is str:
-            __class__._raise_bugcheck("tempfile.gettempdir returned a value with type {0}.".format(type(v).__name__))
+            __class__._raise_bugcheck("os_ops.get_tempdir returned a value with type {0}.".format(type(v).__name__))
 
         if v == "":
-            __class__._raise_bugcheck("tempfile.gettempdir returned an empty string.")
+            __class__._raise_bugcheck("os_ops.get_tempdir returned an empty string.")
 
-        if not os.path.exists(v):
-            __class__._raise_bugcheck("tempfile.gettempdir returned a not exist path [{0}].".format(v))
+        if not self._os_ops.path_exists(v):
+            __class__._raise_bugcheck("os_ops.get_tempdir returned a not exist path [{0}].".format(v))
 
         # OK
         return v

{testgres-1.13.7 → testgres-1.14.1}/src/utils.py

@@ -140,7 +140,7 @@ def get_bin_path2(os_ops: OsOperations, filename):
     assert isinstance(os_ops, OsOperations)
 
     # check if it's already absolute
-    if os.path.isabs(filename):
+    if os_ops.is_abs_path(filename):
         return filename
     if isinstance(os_ops, RemoteOperations):
         pg_config = os.environ.get("PG_CONFIG_REMOTE") or os.environ.get("PG_CONFIG")
@@ -165,6 +165,33 @@ def get_bin_path2(os_ops: OsOperations, filename):
     return filename
 
 
+def get_bin_dir(os_ops: OsOperations) -> str:
+    assert os_ops is not None
+    assert isinstance(os_ops, OsOperations)
+
+    if isinstance(os_ops, RemoteOperations):
+        pg_config = os.environ.get("PG_CONFIG_REMOTE") or os.environ.get("PG_CONFIG")
+    else:
+        # try PG_CONFIG - get from local machine
+        pg_config = os.environ.get("PG_CONFIG")
+
+    if pg_config:
+        bindir = get_pg_config(pg_config, os_ops)["BINDIR"]
+        return bindir
+
+    # try PG_BIN
+    pg_bin = os_ops.environ("PG_BIN")
+    if pg_bin:
+        return pg_bin
+
+    pg_config_path = os_ops.find_executable('pg_config')
+    if pg_config_path:
+        bindir = get_pg_config(pg_config_path)["BINDIR"]
+        return bindir
+
+    raise RuntimeError("BinDir is not detected.")
+
+
 def get_pg_config(pg_config_path=None, os_ops=None):
     """
     Return output of pg_config (provided that it is installed).

{testgres-1.13.7 → testgres-1.14.1/testgres.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres
-Version: 1.13.7
+Version: 1.14.1
 Summary: Testing utility for PostgreSQL and its extensions
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL
@@ -27,11 +27,10 @@ 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.1.0
+Requires-Dist: testgres.os_ops<3.0.0,>=2.3.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)
-[![codecov](https://codecov.io/gh/postgrespro/testgres/branch/master/graph/badge.svg)](https://codecov.io/gh/postgrespro/testgres)
+[![CI Status](https://img.shields.io/github/actions/workflow/status/postgrespro/testgres/.github/workflows/ci.yml?label=CI)](https://github.com/postgrespro/testgres/actions/workflows/ci.yml)
 [![PyPI package version](https://badge.fury.io/py/testgres.svg)](https://badge.fury.io/py/testgres)
 [![PyPI python versions](https://img.shields.io/pypi/pyversions/testgres)](https://pypi.org/project/testgres)
 [![PyPI downloads](https://img.shields.io/pypi/dm/testgres)](https://pypi.org/project/testgres)

{testgres-1.13.7 → testgres-1.14.1}/testgres.egg-info/SOURCES.txt

@@ -32,6 +32,7 @@ testgres.egg-info/SOURCES.txt
 testgres.egg-info/dependency_links.txt
 testgres.egg-info/requires.txt
 testgres.egg-info/top_level.txt
+tests/test_api.py
 tests/test_config.py
 tests/test_os_ops_common.py
 tests/test_os_ops_local.py

{testgres-1.13.7 → testgres-1.14.1}/testgres.egg-info/requires.txt

@@ -3,4 +3,4 @@ port-for>=0.4
 six>=1.9.0
 psutil
 packaging
-testgres.os_ops<3.0.0,>=2.1.0
+testgres.os_ops<3.0.0,>=2.3.0

testgres-1.14.1/tests/test_api.py

@@ -0,0 +1,30 @@
+from src import api as testgres_api
+from src.node import PostgresNode
+
+from tests.helpers.global_data import OsOpsDescrs
+
+
+class TestAPI:
+    def test_001__get_new_node(self):
+        C_NODE_NAME = "abc"
+
+        with testgres_api.get_new_node(name=C_NODE_NAME) as node:
+            assert type(node) is PostgresNode
+            assert node.name == C_NODE_NAME
+            node.init()
+            node.slow_start()
+            node.stop()
+        return
+
+    def test_001__get_remote_node(self):
+        C_NODE_NAME = "abc"
+
+        conn_params = OsOpsDescrs.sm_remote_conn_params
+
+        with testgres_api.get_remote_node(name=C_NODE_NAME, conn_params=conn_params) as node:
+            assert type(node) is PostgresNode
+            assert node.name == C_NODE_NAME
+            node.init()
+            node.slow_start()
+            node.stop()
+        return

{testgres-1.13.7 → testgres-1.14.1}/tests/test_testgres_common.py

@@ -94,8 +94,8 @@ class TestTestgresCommon:
 
         # Author: Mark G.
         assert v.major == 1
-        assert v.minor == 13
-        assert v.micro == 7
+        assert v.minor == 14
+        assert v.micro == 1
 
         assert str(v) == testgres_version
         return
@@ -132,7 +132,53 @@ class TestTestgresCommon:
             assert (isinstance(node.version, PgVer))
             assert (node.version == PgVer(version))
 
+    def test_node_constructor__default(self):
+        node = PostgresNode()
+        assert node._os_ops is not None
+        assert isinstance(node._os_ops, OsOperations)
+        assert node._port_manager is not None
+        assert isinstance(node._port_manager, PortManager)
+        assert node._name is not None
+        assert type(node._name) is str
+        assert node._name != ""
+        assert node._base_dir is None
+        return
+
+    def test_node_constructor__host(self):
+        C_HOST = "AbCdE"
+
+        unique_id = uuid.uuid4().hex
+
+        with PostgresNode(host=C_HOST) as node:
+            assert node._host == C_HOST
+            assert node.host == C_HOST
+            assert isinstance(node.os_ops, OsOperations)
+
+            tmpdir = node.os_ops.get_tempdir()
+            nodedir2 = node.os_ops.build_path(tmpdir, "node2--" + unique_id)
+
+            C_NODE2_NAME = "node2"
+
+            with node.clone_with_new_name_and_base_dir(
+                name=C_NODE2_NAME,
+                base_dir=nodedir2,
+            ) as node2:
+                assert node2 is not None
+                assert node2 is not node
+
+                assert node2._host == C_HOST
+                assert node2.host == C_HOST
+
+                assert node2._name == C_NODE2_NAME
+                assert node2._base_dir == nodedir2
+                assert node2._port != node._port
+                assert node2._os_ops is node._os_ops
+                assert node2._port_manager is node._port_manager
+        return
+
     def test_node_repr(self, node_svc: PostgresNodeService):
+        assert isinstance(node_svc, PostgresNodeService)
+
         with __class__.helper__get_node(node_svc).init() as node:
             pattern = r"PostgresNode\(name='.+', port=.+, base_dir='.+'\)"
             assert re.match(pattern, str(node)) is not None
@@ -2422,13 +2468,14 @@ where c.relname=%s;"""
     class tag_rmdirs_protector:
         _os_ops: OsOperations
         _cwd: str
-        _old_rmdirs: any
+        _old_rmdirs: typing.Optional[typing.Callable]
         _cwd: str
 
         def __init__(self, os_ops: OsOperations):
             self._os_ops = os_ops
             self._cwd = os.path.abspath(os_ops.cwd())
             self._old_rmdirs = os_ops.rmdirs
+            return
 
         def __enter__(self):
             assert self._os_ops.rmdirs == self._old_rmdirs
@@ -2437,6 +2484,7 @@ where c.relname=%s;"""
 
         def __exit__(self, exc_type, exc_val, exc_tb):
             assert self._os_ops.rmdirs == self.proxy__rmdirs
+            assert isinstance(self._old_rmdirs, typing.Callable)
             self._os_ops.rmdirs = self._old_rmdirs
             return False
 
@@ -2465,7 +2513,7 @@ where c.relname=%s;"""
             assert node_app.os_ops is os_ops
 
             with pytest.raises(expected_exception=BaseException) as x:
-                node_app.make_empty(base_dir=None)
+                node_app.make_empty(base_dir=None)  # type: ignore
 
             if type(x.value) is AssertionError:
                 pass