async def test_resolve_hostaddr_async_no_resolve(monkeypatch, conninfo, want,
env, fail_resolve):
if env:
for k, v in env.items():
monkeypatch.setenv(k, v)
params = conninfo_to_dict(conninfo)
params = await psycopg._dns.resolve_hostaddr_async( # type: ignore[attr-defined]
params)
assert conninfo_to_dict(want) == params
async def test_srv_async(conninfo, want, env, afake_srv, retries, monkeypatch):
if env:
for k, v in env.items():
monkeypatch.setenv(k, v)
async for retry in retries:
with retry:
params = conninfo_to_dict(conninfo)
params = await (
psycopg._dns.resolve_srv_async( # type: ignore[attr-defined]
params))
assert conninfo_to_dict(want) == params
def test_connect_args(monkeypatch, pgconn, args, kwargs, want):
the_conninfo = None
def fake_connect(conninfo):
nonlocal the_conninfo
the_conninfo = conninfo
return pgconn
yield
monkeypatch.setattr(psycopg.connection, "connect", fake_connect)
psycopg.Connection.connect(*args, **kwargs)
assert conninfo_to_dict(the_conninfo) == conninfo_to_dict(want)
def test_srv(conninfo, want, env, fake_srv, retries, monkeypatch):
if env:
for k, v in env.items():
monkeypatch.setenv(k, v)
# retries are needed because weight order is random, although wrong order
# is unlikely.
for retry in retries:
with retry:
params = conninfo_to_dict(conninfo)
params = psycopg._dns.resolve_srv(
params) # type: ignore[attr-defined]
assert conninfo_to_dict(want) == params
async def test_connect_args(monkeypatch, pgconn, args, kwargs, want):
the_conninfo: str
def fake_connect(conninfo):
nonlocal the_conninfo
the_conninfo = conninfo
return pgconn
yield
monkeypatch.setattr(psycopg.connection, "connect", fake_connect)
conn = await psycopg.AsyncConnection.connect(*args, **kwargs)
assert conninfo_to_dict(the_conninfo) == conninfo_to_dict(want)
await conn.close()
async def test_resolve_hostaddr_conn(monkeypatch, fake_resolve):
got = []
def fake_connect_gen(conninfo, **kwargs):
got.append(conninfo)
1 / 0
monkeypatch.setattr(psycopg.AsyncConnection, "_connect_gen",
fake_connect_gen)
# TODO: not enabled by default, but should be usable to make a subclass
class AsyncDnsConnection(psycopg.AsyncConnection[Row]):
@classmethod
async def _get_connection_params(cls, conninfo, **kwargs):
params = await super()._get_connection_params(conninfo, **kwargs)
params = await (
psycopg._dns.
resolve_hostaddr_async( # type: ignore[attr-defined]
params))
return params
with pytest.raises(ZeroDivisionError):
await AsyncDnsConnection.connect("host=foo.com")
assert len(got) == 1
want = {"host": "foo.com", "hostaddr": "1.1.1.1"}
assert conninfo_to_dict(got[0]) == want
def test_get_params(self, conn, dsn):
info = conn.info.get_parameters()
for k, v in conninfo_to_dict(dsn).items():
if k != "password":
assert info.get(k) == v
else:
assert k not in info
def test_srv_bad(conninfo, env, fake_srv, monkeypatch):
if env:
for k, v in env.items():
monkeypatch.setenv(k, v)
params = conninfo_to_dict(conninfo)
with pytest.raises(psycopg.OperationalError):
psycopg._dns.resolve_srv(params) # type: ignore[attr-defined]
async def test_resolve_hostaddr_async_bad(monkeypatch, conninfo, env,
fake_resolve):
if env:
for k, v in env.items():
monkeypatch.setenv(k, v)
params = conninfo_to_dict(conninfo)
with pytest.raises(psycopg.Error):
await psycopg._dns.resolve_hostaddr_async( # type: ignore[attr-defined]
params)
def test_dsn_env(self, dsn, monkeypatch):
dsn = conninfo_to_dict(dsn)
dsn.pop("application_name", None)
monkeypatch.delenv("PGAPPNAME", raising=False)
with psycopg.connect(**dsn) as conn:
assert "application_name=" not in conn.info.dsn
monkeypatch.setenv("PGAPPNAME", "hello test")
with psycopg.connect(**dsn) as conn:
assert "application_name='hello test'" in conn.info.dsn
def test_get_params_env(self, dsn, monkeypatch):
dsn = conninfo_to_dict(dsn)
dsn.pop("application_name", None)
monkeypatch.delenv("PGAPPNAME", raising=False)
with psycopg.connect(**dsn) as conn:
assert "application_name" not in conn.info.get_parameters()
monkeypatch.setenv("PGAPPNAME", "hello test")
with psycopg.connect(**dsn) as conn:
assert (
conn.info.get_parameters()["application_name"] == "hello test")
def __init__(self, server_dsn):
cdict = conninfo.conninfo_to_dict(server_dsn)
# Get server params
self.server_port = cdict.get("port", "5432")
if "host" not in cdict or cdict["host"].startswith("/"):
self.server_host = "localhost"
else:
self.server_host = cdict["host"]
# Get client params
self.client_host = "localhost"
self.client_port = self._get_random_port()
# Make a connection string to the proxy
cdict["host"] = self.client_host
cdict["port"] = self.client_port
cdict["sslmode"] = "disable" # not supported by the proxy
self.client_dsn = conninfo.make_conninfo(**cdict)
# The running proxy process
self.proc = None
def test_make_conninfo(conninfo, kwargs, exp):
out = make_conninfo(conninfo, **kwargs)
assert conninfo_to_dict(out) == conninfo_to_dict(exp)
def test_get_connection_params(dsn, kwargs, exp):
params = Connection._get_connection_params(dsn, **kwargs)
conninfo = make_conninfo(**params)
assert conninfo_to_dict(conninfo) == exp[0]
assert params.get("connect_timeout") == exp[1]
def test__conninfo_connect_timeout(dsn, kwargs, exp):
conninfo, connect_timeout = _conninfo_connect_timeout(dsn, **kwargs)
assert conninfo_to_dict(conninfo) == exp[0]
assert connect_timeout == exp[1]
async def test_resolve_hostaddr_async(conninfo, want, env, fake_resolve):
params = conninfo_to_dict(conninfo)
params = await psycopg._dns.resolve_hostaddr_async( # type: ignore[attr-defined]
params)
assert conninfo_to_dict(want) == params
async def test_get_connection_params(dsn, kwargs, exp):
params = await AsyncConnection._get_connection_params(dsn, **kwargs)
conninfo = make_conninfo(**params)
assert conninfo_to_dict(conninfo) == exp[0]
assert params["connect_timeout"] == exp[1]
def test_dsn(self, conn, dsn):
dsn = conn.info.dsn
assert "password" not in dsn
for k, v in conninfo_to_dict(dsn).items():
if k != "password":
assert f"{k}=" in dsn
def test_conninfo_to_dict(conninfo, exp):
assert conninfo_to_dict(conninfo) == exp
async def test_resolve_hostaddr_async(conninfo, want, env, fake_resolve):
params = conninfo_to_dict(conninfo)
params = await psycopg._dns.resolve_hostaddr_async(params)
assert conninfo_to_dict(want) == params
