Consistently use postgres/postgres as database/user pair in tests

When running against a temporary cluster, make sure the default
superuser and database name are 'postgres'.

When PGHOST environment variable is specified, rely on the default
connection spec heuristics.

Author: elprans

asyncpg/_testbase.py

@@ -128,16 +128,30 @@ def handler(loop, ctx):
 _default_cluster = None
 
 
-def _start_cluster(ClusterCls, cluster_kwargs, server_settings):
+def _start_cluster(ClusterCls, cluster_kwargs, server_settings,
+                   initdb_options=None):
     cluster = ClusterCls(**cluster_kwargs)
-    cluster.init()
+    cluster.init(**(initdb_options or {}))
     cluster.trust_local_connections()
     cluster.start(port='dynamic', server_settings=server_settings)
     atexit.register(_shutdown_cluster, cluster)
     return cluster
 
 
-def _start_default_cluster(server_settings={}):
+def _get_initdb_options(initdb_options=None):
+    if not initdb_options:
+        initdb_options = {}
+    else:
+        initdb_options = dict(initdb_options)
+
+    # Make the default superuser name stable.
+    if 'username' not in initdb_options:
+        initdb_options['username'] = 'postgres'
+
+    return initdb_options
+
+
+def _start_default_cluster(server_settings={}, initdb_options=None):
     global _default_cluster
 
     if _default_cluster is None:
@@ -147,7 +161,9 @@ def _start_default_cluster(server_settings={}):
             _default_cluster = pg_cluster.RunningCluster()
         else:
             _default_cluster = _start_cluster(
-                pg_cluster.TempCluster, {}, server_settings)
+                pg_cluster.TempCluster, cluster_kwargs={},
+                server_settings=server_settings,
+                initdb_options=_get_initdb_options(initdb_options))
 
     return _default_cluster
 
@@ -193,15 +209,33 @@ def setUpClass(cls):
         super().setUpClass()
         cls.setup_cluster()
 
-    def create_pool(self, pool_class=pg_pool.Pool, **kwargs):
-        conn_spec = self.cluster.get_connection_spec()
+    @classmethod
+    def get_connection_spec(cls, kwargs={}):
+        conn_spec = cls.cluster.get_connection_spec()
         conn_spec.update(kwargs)
+        if not os.environ.get('PGHOST'):
+            if 'database' not in conn_spec:
+                conn_spec['database'] = 'postgres'
+            if 'user' not in conn_spec:
+                conn_spec['user'] = 'postgres'
+        return conn_spec
+
+    def create_pool(self, pool_class=pg_pool.Pool, **kwargs):
+        conn_spec = self.get_connection_spec(kwargs)
         return create_pool(loop=self.loop, pool_class=pool_class, **conn_spec)
 
+    @classmethod
+    def connect(cls, **kwargs):
+        conn_spec = cls.get_connection_spec(kwargs)
+        return pg_connection.connect(**conn_spec, loop=cls.loop)
+
     @classmethod
     def start_cluster(cls, ClusterCls, *,
-                      cluster_kwargs={}, server_settings={}):
-        return _start_cluster(ClusterCls, cluster_kwargs, server_settings)
+                      cluster_kwargs={}, server_settings={},
+                      initdb_options={}):
+        return _start_cluster(
+            ClusterCls, cluster_kwargs,
+            server_settings, _get_initdb_options(initdb_options))
 
 
 def with_connection_options(**options):
@@ -223,13 +257,7 @@ def setUp(self):
         # Extract options set up with `with_connection_options`.
         test_func = getattr(self, self._testMethodName).__func__
         opts = getattr(test_func, '__connect_options__', {})
-        if 'database' not in opts:
-            opts = dict(opts)
-            opts['database'] = 'postgres'
-
-        self.con = self.loop.run_until_complete(
-            self.cluster.connect(loop=self.loop, **opts))
-
+        self.con = self.loop.run_until_complete(self.connect(**opts))
         self.server_version = self.con.get_server_version()
 
     def tearDown(self):

asyncpg/cluster.py

@@ -448,6 +448,7 @@ def _test_connection(self, timeout=60):
                 try:
                     con = loop.run_until_complete(
                         asyncpg.connect(database='postgres',
+                                        user='postgres',
                                         timeout=5, loop=loop,
                                         **self._connection_addr))
                 except (OSError, asyncio.TimeoutError,

tests/test_codecs.py

@@ -1011,7 +1011,7 @@ async def test_custom_codec_override_binary(self):
         """Test overriding core codecs."""
         import json
 
-        conn = await self.cluster.connect(database='postgres', loop=self.loop)
+        conn = await self.connect()
         try:
             def _encoder(value):
                 return json.dumps(value).encode('utf-8')
@@ -1035,7 +1035,7 @@ async def test_custom_codec_override_text(self):
         """Test overriding core codecs."""
         import json
 
-        conn = await self.cluster.connect(database='postgres', loop=self.loop)
+        conn = await self.connect()
         try:
             def _encoder(value):
                 return json.dumps(value)
@@ -1087,7 +1087,7 @@ async def test_custom_codec_override_tuple(self):
             ('interval', (2, 3, 1), '2 mons 3 days 00:00:00.000001')
         ]
 
-        conn = await self.cluster.connect(database='postgres', loop=self.loop)
+        conn = await self.connect()
 
         def _encoder(value):
             return tuple(value)

tests/test_connect.py

@@ -137,57 +137,50 @@ async def _try_connect(self, **kwargs):
         if _system == 'Windows':
             for tried in range(3):
                 try:
-                    return await self.cluster.connect(**kwargs)
+                    return await self.connect(**kwargs)
                 except asyncpg.ConnectionDoesNotExistError:
                     pass
 
-        return await self.cluster.connect(**kwargs)
+        return await self.connect(**kwargs)
 
     async def test_auth_bad_user(self):
         with self.assertRaises(
                 asyncpg.InvalidAuthorizationSpecificationError):
-            await self._try_connect(user='__nonexistent__',
-                                    database='postgres',
-                                    loop=self.loop)
+            await self._try_connect(user='__nonexistent__')
 
     async def test_auth_trust(self):
-        conn = await self.cluster.connect(
-            user='trust_user', database='postgres', loop=self.loop)
+        conn = await self.connect(user='trust_user')
         await conn.close()
 
     async def test_auth_reject(self):
         with self.assertRaisesRegex(
                 asyncpg.InvalidAuthorizationSpecificationError,
                 'pg_hba.conf rejects connection'):
-            await self._try_connect(
-                user='reject_user', database='postgres',
-                loop=self.loop)
+            await self._try_connect(user='reject_user')
 
     async def test_auth_password_cleartext(self):
-        conn = await self.cluster.connect(
-            user='password_user', database='postgres',
-            password='correctpassword', loop=self.loop)
+        conn = await self.connect(
+            user='password_user',
+            password='correctpassword')
         await conn.close()
 
         with self.assertRaisesRegex(
                 asyncpg.InvalidPasswordError,
                 'password authentication failed for user "password_user"'):
             await self._try_connect(
-                user='password_user', database='postgres',
-                password='wrongpassword', loop=self.loop)
+                user='password_user',
+                password='wrongpassword')
 
     async def test_auth_password_md5(self):
-        conn = await self.cluster.connect(
-            user='md5_user', database='postgres', password='correctpassword',
-            loop=self.loop)
+        conn = await self.connect(
+            user='md5_user', password='correctpassword')
         await conn.close()
 
         with self.assertRaisesRegex(
                 asyncpg.InvalidPasswordError,
                 'password authentication failed for user "md5_user"'):
             await self._try_connect(
-                user='md5_user', database='postgres', password='wrongpassword',
-                loop=self.loop)
+                user='md5_user', password='wrongpassword')
 
     async def test_auth_unsupported(self):
         pass
@@ -494,11 +487,9 @@ async def test_connection_ssl_to_no_ssl_server(self):
         ssl_context.load_verify_locations(SSL_CA_CERT_FILE)
 
         with self.assertRaisesRegex(ConnectionError, 'rejected SSL'):
-            await self.cluster.connect(
+            await self.connect(
                 host='localhost',
                 user='ssl_user',
-                database='postgres',
-                loop=self.loop,
                 ssl=ssl_context)
 
     async def test_connection_ssl_unix(self):
@@ -507,15 +498,17 @@ async def test_connection_ssl_unix(self):
 
         with self.assertRaisesRegex(asyncpg.InterfaceError,
                                     'can only be enabled for TCP addresses'):
-            await self.cluster.connect(
+            await self.connect(
                 host='/tmp',
-                loop=self.loop,
                 ssl=ssl_context)
 
     async def test_connection_implicit_host(self):
-        conn_spec = self.cluster.get_connection_spec()
+        conn_spec = self.get_connection_spec()
         con = await asyncpg.connect(
-            port=conn_spec.get('port'), database='postgres', loop=self.loop)
+            port=conn_spec.get('port'),
+            database=conn_spec.get('database'),
+            user=conn_spec.get('user'),
+            loop=self.loop)
         await con.close()
 
 
@@ -576,11 +569,9 @@ async def test_ssl_connection_custom_context(self):
         ssl_context = ssl.SSLContext(ssl.PROTOCOL_SSLv23)
         ssl_context.load_verify_locations(SSL_CA_CERT_FILE)
 
-        con = await self.cluster.connect(
+        con = await self.connect(
             host='localhost',
             user='ssl_user',
-            database='postgres',
-            loop=self.loop,
             ssl=ssl_context)
 
         try:
@@ -595,11 +586,9 @@ async def test_ssl_connection_custom_context(self):
 
     async def test_ssl_connection_default_context(self):
         with self.assertRaisesRegex(ssl.SSLError, 'verify failed'):
-            await self.cluster.connect(
+            await self.connect(
                 host='localhost',
                 user='ssl_user',
-                database='postgres',
-                loop=self.loop,
                 ssl=True)
 
     async def test_ssl_connection_pool(self):

tests/test_introspection.py

@@ -16,8 +16,7 @@ class TestIntrospection(tb.ConnectedTestCase):
     @classmethod
     def setUpClass(cls):
         super().setUpClass()
-        cls.adminconn = cls.loop.run_until_complete(
-            cls.cluster.connect(database='postgres', loop=cls.loop))
+        cls.adminconn = cls.loop.run_until_complete(cls.connect())
         cls.loop.run_until_complete(
             cls.adminconn.execute('CREATE DATABASE asyncpg_intro_test'))
 

tests/test_pool.py

@@ -656,7 +656,8 @@ def setUpClass(cls):
 
         try:
             con = cls.loop.run_until_complete(
-                cls.master_cluster.connect(database='postgres', loop=cls.loop))
+                cls.master_cluster.connect(
+                    database='postgres', user='postgres', loop=cls.loop))
 
             cls.loop.run_until_complete(
                 con.execute('''
@@ -696,8 +697,9 @@ def create_pool(self, **kwargs):
     async def test_standby_pool_01(self):
         for n in {1, 3, 5, 10, 20, 100}:
             with self.subTest(tasksnum=n):
-                pool = await self.create_pool(database='postgres',
-                                              min_size=5, max_size=10)
+                pool = await self.create_pool(
+                    database='postgres', user='postgres',
+                    min_size=5, max_size=10)
 
                 async def worker():
                     con = await pool.acquire()
@@ -710,7 +712,7 @@ async def worker():
 
     async def test_standby_cursors(self):
         con = await self.standby_cluster.connect(
-            database='postgres', loop=self.loop)
+            database='postgres', user='postgres', loop=self.loop)
 
         try:
             async with con.transaction():

tests/test_timeout.py

@@ -114,9 +114,7 @@ async def test_invalid_timeout(self):
             with self.subTest(command_timeout=command_timeout):
                 with self.assertRaisesRegex(ValueError,
                                             'invalid command_timeout'):
-                    await self.cluster.connect(
-                        database='postgres', loop=self.loop,
-                        command_timeout=command_timeout)
+                    await self.connect(command_timeout=command_timeout)
 
         # Note: negative timeouts are OK for method calls.
         for methname in {'fetch', 'fetchrow', 'fetchval', 'execute'}: