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