testgres 1.14.0__tar.gz → 1.14.2__tar.gz

{testgres-1.14.0/testgres.egg-info → testgres-1.14.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres
-Version: 1.14.0
+Version: 1.14.2
 Summary: Testing utility for PostgreSQL and its extensions
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL

{testgres-1.14.0 → testgres-1.14.2}/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.14.0"
+__version__ = "1.14.2"
 
 __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.14.0 → testgres-1.14.2}/src/node.py

@@ -161,6 +161,7 @@ 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
@@ -168,14 +169,17 @@ class PostgresNode(object):
     _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,
-                 bin_dir: typing.Optional[str] = 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.
 
@@ -186,11 +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)
+        assert host is None or type(host) is str
 
         # private
         if os_ops is None:
@@ -219,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
@@ -249,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
 
@@ -317,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,
@@ -324,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
 
@@ -348,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:
@@ -467,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):
@@ -540,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):
         """
@@ -838,7 +863,7 @@ class PostgresNode(object):
         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
@@ -929,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,
@@ -1453,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
@@ -1580,7 +1611,7 @@ 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,
             "-d", dbname or default_dbname(),
@@ -1612,7 +1643,7 @@ class PostgresNode(object):
         _params = [
             self._get_bin_path("pg_restore"),
             "-p", str(self.port),
-            "-h", self.host,
+            "-h", self._host,
             "-U", username,
             "-d", dbname,
             filename
@@ -1620,7 +1651,7 @@ 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)
 
@@ -1888,7 +1919,7 @@ class PostgresNode(object):
         _params = [
             self._get_bin_path("pgbench"),
             "-p", str(self.port),
-            "-h", self.host,
+            "-h", self._host,
             "-U", username or self._os_ops.username
         ] + options  # yapf: disable
 
@@ -1961,7 +1992,7 @@ class PostgresNode(object):
         _params = [
             self._get_bin_path("pgbench"),
             "-p", str(self.port),
-            "-h", self.host,
+            "-h", self._host,
             "-U", username or self._os_ops.username
         ] + options  # yapf: disable
 

{testgres-1.14.0 → testgres-1.14.2}/src/node_app.py

@@ -99,7 +99,7 @@ class NodeApp:
             port=port,
             bin_dir=bin_dir,
             os_ops=self._os_ops,
-            port_manager=port_manager
+            port_manager=port_manager,
         )
 
         try:
@@ -150,7 +150,10 @@ class NodeApp:
 
         node.init(
             initdb_params=final_initdb_params,
-            allow_streaming=set_replication
+            # params for node.default_conf
+            fsync=False,
+            allow_streaming=set_replication,
+            log_statement="none",
         )
 
         # set major version
@@ -164,11 +167,9 @@ class NodeApp:
         options = {
             'max_connections': 100,
             'shared_buffers': '10MB',
-            'fsync': 'off',
             'wal_level': 'logical',
             'hot_standby': 'off',
             'log_line_prefix': '%t [%p]: [%l-1] ',
-            'log_statement': 'none',
             'log_duration': 'on',
             'log_min_duration_statement': 0,
             'log_connections': 'on',

{testgres-1.14.0 → testgres-1.14.2/testgres.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: testgres
-Version: 1.14.0
+Version: 1.14.2
 Summary: Testing utility for PostgreSQL and its extensions
 Author-email: Postgres Professional <testgres@postgrespro.ru>
 License: PostgreSQL

{testgres-1.14.0 → testgres-1.14.2}/tests/test_testgres_common.py

@@ -51,6 +51,7 @@ import subprocess
 import typing
 import types
 import psutil
+import testgres.postgres_configuration as testgres_pgconf
 
 from packaging.version import Version
 
@@ -95,7 +96,7 @@ class TestTestgresCommon:
         # Author: Mark G.
         assert v.major == 1
         assert v.minor == 14
-        assert v.micro == 0
+        assert v.micro == 2
 
         assert str(v) == testgres_version
         return
@@ -132,7 +133,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
@@ -2714,6 +2761,56 @@ where c.relname=%s;"""
         node_svc.os_ops.rmdirs(tmp_dir)
         return
 
+    def test_node_app__make_empty_and_pgconf(self, node_svc: PostgresNodeService):
+        assert type(node_svc) is PostgresNodeService
+
+        assert type(node_svc) is PostgresNodeService
+
+        assert isinstance(node_svc.os_ops, OsOperations)
+        assert node_svc.port_manager is not None
+        assert isinstance(node_svc.port_manager, PortManager)
+
+        tmp_dir = node_svc.os_ops.mkdtemp()
+        assert tmp_dir is not None
+        assert type(tmp_dir) is str
+        logging.info("temp directory is [{}]".format(tmp_dir))
+
+        # -----------
+        node_app = NodeApp(
+            test_path=tmp_dir,
+            os_ops=node_svc.os_ops,
+            port_manager=node_svc.port_manager
+        )
+
+        # TODO: We have to use node_svc.os_ops here
+
+        with node_app.make_simple("abc") as node:
+            node_conf = testgres_pgconf.PostgresConfiguration(node.data_dir)
+
+            logging.info("Configuration is readed ...")
+            testgres_pgconf.PostgresConfigurationReader.LoadConfiguration(node_conf)
+
+            logging.info("Configuration is checked ...")
+            prop__port = node_conf.GetOptionValue("port")
+            assert type(prop__port) is int
+            assert prop__port == node.port
+            # presets are checked
+            prop__fsync = node_conf.GetOptionValue("fsync")
+            assert prop__fsync == "off" or prop__fsync is False
+            prop__log_statement = node_conf.GetOptionValue("log_statement")
+            assert type(prop__log_statement) is str
+            assert prop__log_statement == "none"
+            prop__wal_level = node_conf.GetOptionValue("wal_level")
+            assert type(prop__wal_level) is str
+            assert prop__wal_level == "logical"
+
+            logging.info("Configuration is written ...")
+            testgres_pgconf.PostgresConfigurationWriter.WriteConfiguration(node_conf)
+
+            logging.info("Node is started ...")
+            node.slow_start()
+        return
+
     @staticmethod
     def helper__get_node(
         node_svc: PostgresNodeService,