snowflake-sql-api 0.1.0__tar.gz → 0.1.1__tar.gz

{snowflake_sql_api-0.1.0 → snowflake_sql_api-0.1.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: snowflake-sql-api
-Version: 0.1.0
+Version: 0.1.1
 Summary: Lightweight, pure-Python client for Snowflake's SQL API v2
 Project-URL: Homepage, https://github.com/hampsterx/snowflake-sql-api
 Project-URL: Repository, https://github.com/hampsterx/snowflake-sql-api
@@ -47,7 +47,7 @@ Requires-Dist: cryptography>=3.4
 Requires-Dist: httpx>=0.24
 Requires-Dist: pyjwt>=2.4
 Provides-Extra: dev
-Requires-Dist: black<25.10,>=24.0; extra == 'dev'
+Requires-Dist: black<25.12,>=24.0; extra == 'dev'
 Requires-Dist: build>=1.0; extra == 'dev'
 Requires-Dist: coverage[toml]>=7.0; extra == 'dev'
 Requires-Dist: mypy>=1.8; extra == 'dev'

{snowflake_sql_api-0.1.0 → snowflake_sql_api-0.1.1}/pyproject.toml

@@ -43,7 +43,7 @@ dev = [
     "ruff>=0.4",
     # Capped below 25.10: 25.12.0+ drop Python 3.9, which the package still
     # supports. Keeps CI and the pinned pre-commit hook on the same black.
-    "black>=24.0,<25.10",
+    "black>=24.0,<25.12",
     "mypy>=1.8",
     "build>=1.0",
     "pre-commit>=3.5",
@@ -134,9 +134,9 @@ markers = [
 [tool.coverage.run]
 source = ["snowflake_sql_api"]
 branch = true
-# cli.py is exercised end-to-end by the smoke suite; row_mapping.py is a Phase 8
-# stub. Both are out of the Phase 2 core-coverage scope.
-omit = ["snowflake_sql_api/cli.py", "snowflake_sql_api/row_mapping.py"]
+# row_mapping.py is a Phase 8 stub, out of the Phase 2 core-coverage scope.
+# cli.py is covered by tests/test_cli.py.
+omit = ["snowflake_sql_api/row_mapping.py"]
 
 [tool.coverage.report]
 show_missing = true

{snowflake_sql_api-0.1.0 → snowflake_sql_api-0.1.1}/snowflake_sql_api/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.0'
-__version_tuple__ = version_tuple = (0, 1, 0)
+__version__ = version = '0.1.1'
+__version_tuple__ = version_tuple = (0, 1, 1)
 
 __commit_id__ = commit_id = None

{snowflake_sql_api-0.1.0 → snowflake_sql_api-0.1.1}/snowflake_sql_api/cli.py

@@ -68,7 +68,7 @@ def main(argv: Optional[Sequence[str]] = None) -> int:
         return 2
     if args.command == "query":
         return _run_query(args.sql)
-    return 0
+    return 0  # pragma: no cover - argparse only yields None or a known subcommand
 
 
 if __name__ == "__main__":  # pragma: no cover

{snowflake_sql_api-0.1.0 → snowflake_sql_api-0.1.1}/snowflake_sql_api/testing.py

@@ -599,7 +599,7 @@ def make_client(
     from .client import SnowflakeClient
 
     _reject_managed_kwargs("make_client", kwargs)
-    return SnowflakeClient(
+    client = SnowflakeClient(
         account,
         user,
         private_key=_throwaway_key(),
@@ -607,6 +607,8 @@ def make_client(
         poll_interval=poll_interval,
         **kwargs,
     )
+    client._transport._owns_client = True
+    return client
 
 
 def make_async_client(
@@ -621,7 +623,7 @@ def make_async_client(
     from .aclient import AsyncSnowflakeClient
 
     _reject_managed_kwargs("make_async_client", kwargs)
-    return AsyncSnowflakeClient(
+    client = AsyncSnowflakeClient(
         account,
         user,
         private_key=_throwaway_key(),
@@ -629,6 +631,8 @@ def make_async_client(
         poll_interval=poll_interval,
         **kwargs,
     )
+    client._transport._owns_client = True
+    return client
 
 
 # ---------------------------------------------------------------------------

{snowflake_sql_api-0.1.0 → snowflake_sql_api-0.1.1}/tests/conftest.py

@@ -25,6 +25,12 @@ from cryptography.hazmat.primitives.asymmetric.rsa import RSAPrivateKey
 PASSPHRASE = b"correct horse battery staple"
 
 
+def pytest_configure(config: pytest.Config) -> None:
+    """Load shipped testing fixtures when pytest11 entry points are unavailable."""
+    if not config.pluginmanager.hasplugin("snowflake_sql_api"):
+        config.pluginmanager.import_plugin("snowflake_sql_api.testing")
+
+
 @pytest.fixture
 def fake_account() -> str:
     """A region-suffixed account locator for auth-normalization tests."""

snowflake_sql_api-0.1.1/tests/test_cli.py

@@ -0,0 +1,143 @@
+"""Unit tests for the ``snowflake-sql-api`` CLI (``cli.py``).
+
+Drive ``build_parser()`` / ``main()`` with ``argv`` injection and a stubbed
+client (``from_env`` monkeypatched to a :class:`FakeSnowflake`-backed client), so
+no network and no real account. Covers the exit-code contract documented in
+``docs/cli.md`` plus the ``_json_default`` serializer.
+"""
+
+from __future__ import annotations
+
+import json
+from datetime import date, datetime, time, timezone
+from decimal import Decimal
+
+import pytest
+
+from snowflake_sql_api import cli
+from snowflake_sql_api.client import SnowflakeClient
+from snowflake_sql_api.testing import FakeSnowflake, make_client
+
+
+@pytest.fixture
+def stub_from_env(monkeypatch: pytest.MonkeyPatch) -> FakeSnowflake:
+    """Point ``SnowflakeClient.from_env`` at a fresh FakeSnowflake-backed client.
+
+    Returns the fake so a test can register results before invoking the CLI.
+    """
+    fake = FakeSnowflake()
+
+    def _from_env() -> SnowflakeClient:
+        return make_client(fake)
+
+    monkeypatch.setattr(SnowflakeClient, "from_env", staticmethod(_from_env))
+    return fake
+
+
+# ---------------------------------------------------------------------------
+# build_parser / argv plumbing
+# ---------------------------------------------------------------------------
+
+
+def test_build_parser_parses_query() -> None:
+    args = cli.build_parser().parse_args(["query", "SELECT 1"])
+    assert args.command == "query"
+    assert args.sql == "SELECT 1"
+
+
+def test_version(capsys: pytest.CaptureFixture[str]) -> None:
+    # argparse's `version` action prints then raises SystemExit(0).
+    from snowflake_sql_api import __version__
+
+    with pytest.raises(SystemExit) as excinfo:
+        cli.main(["--version"])
+    assert excinfo.value.code == 0
+    assert __version__ in capsys.readouterr().out
+
+
+def test_no_subcommand_prints_help_and_exits_2(
+    capsys: pytest.CaptureFixture[str],
+) -> None:
+    assert cli.main([]) == 2
+    out = capsys.readouterr().out
+    assert "usage:" in out
+    assert "query" in out
+
+
+# ---------------------------------------------------------------------------
+# query command (stubbed client)
+# ---------------------------------------------------------------------------
+
+
+def test_query_happy_path_prints_json(
+    stub_from_env: FakeSnowflake, capsys: pytest.CaptureFixture[str]
+) -> None:
+    stub_from_env.register(
+        "SELECT id, name FROM users",
+        [{"ID": 1, "NAME": "alice"}, {"ID": 2, "NAME": "bob"}],
+    )
+    assert cli.main(["query", "SELECT id, name FROM users"]) == 0
+    out = capsys.readouterr().out
+    assert json.loads(out) == [
+        {"ID": 1, "NAME": "alice"},
+        {"ID": 2, "NAME": "bob"},
+    ]
+
+
+def test_query_serializes_non_json_native_values(
+    stub_from_env: FakeSnowflake, capsys: pytest.CaptureFixture[str]
+) -> None:
+    # Decimal/timestamp/binary travel through _json_default on the way to stdout.
+    stub_from_env.register(
+        "SELECT amount, ts, blob",
+        [
+            {
+                "AMOUNT": Decimal("10.50"),
+                "TS": datetime(2024, 1, 2, 3, 4, 5, tzinfo=timezone.utc),
+                "BLOB": b"\x00\xff",
+            }
+        ],
+    )
+    assert cli.main(["query", "SELECT amount, ts, blob"]) == 0
+    row = json.loads(capsys.readouterr().out)[0]
+    assert row["AMOUNT"] == "10.50"
+    assert row["TS"].startswith("2024-01-02T03:04:05")
+    assert row["BLOB"] == "00ff"
+
+
+def test_query_snowflake_error_exits_1(
+    stub_from_env: FakeSnowflake, capsys: pytest.CaptureFixture[str]
+) -> None:
+    stub_from_env.register_error(
+        "SELECT * FROM nope", "Object 'NOPE' does not exist", code="002003"
+    )
+    assert cli.main(["query", "SELECT * FROM nope"]) == 1
+    captured = capsys.readouterr()
+    assert captured.out == ""
+    assert captured.err.startswith("error: ")
+    assert "does not exist" in captured.err
+
+
+# ---------------------------------------------------------------------------
+# _json_default serializer (direct unit coverage, incl. the TypeError branch)
+# ---------------------------------------------------------------------------
+
+
+@pytest.mark.parametrize(
+    ("value", "expected"),
+    [
+        (Decimal("1.25"), "1.25"),
+        (datetime(2024, 6, 1, 12, 30, 0), "2024-06-01T12:30:00"),
+        (date(2024, 6, 1), "2024-06-01"),
+        (time(9, 15, 30), "09:15:30"),
+        (b"\xde\xad", "dead"),
+        (bytearray(b"\xbe\xef"), "beef"),
+    ],
+)
+def test_json_default_serializes(value: object, expected: str) -> None:
+    assert cli._json_default(value) == expected
+
+
+def test_json_default_rejects_unsupported() -> None:
+    with pytest.raises(TypeError, match="cannot serialize"):
+        cli._json_default(object())

snowflake_sql_api-0.1.1/tests/test_import_footprint.py

@@ -0,0 +1,108 @@
+"""Guard the install footprint: a bare ``import snowflake_sql_api`` stays light.
+
+The package's whole value proposition is a small install and a fast cold start
+(serverless / Lambda). Two regressions would silently erode that:
+
+1. A heavy optional dependency (pandas / pyarrow) getting imported at module top
+   instead of behind its extra. The ``[pandas]`` feature must stay opt-in.
+2. Import time ballooning for any reason.
+
+Both checks run in a **fresh subprocess** so the parent pytest process's
+already-imported modules can't mask a regression (pandas may well be imported by
+the time these tests run). The leak check installs a recording meta-path finder
+that stubs the forbidden names, so it fires deterministically whether or not the
+real packages are installed: a module-top ``import pandas`` is caught even when
+it is guarded by ``try/except ImportError`` and even in an env without pandas.
+"""
+
+from __future__ import annotations
+
+import subprocess
+import sys
+
+# Heavy optional deps that a bare import must never pull in. pandas is the
+# ``[pandas]`` extra; pyarrow/numpy ride in with it. If any is imported at module
+# top, something bypassed the optional-import guard.
+FORBIDDEN_ON_BARE_IMPORT = ("pandas", "pyarrow", "numpy")
+
+# Generous ceiling: the real cold import (httpx + PyJWT + cryptography, all pure
+# Python or fast C imports) is well under a second. This is a coarse backstop
+# against an order-of-magnitude regression, not a precise benchmark, so the bound
+# is deliberately loose and we assert on the best of several samples to stay
+# non-flaky on shared CI runners.
+IMPORT_BUDGET_SECONDS = 2.5
+TIMING_SAMPLES = 3
+
+# Subprocess: record any *attempt* to import a forbidden module during a bare
+# `import snowflake_sql_api`. The recorder returns a stub module for forbidden
+# names, so the import succeeds (and is recorded) regardless of whether the real
+# dependency is installed -- making the guard deterministic across environments.
+_LEAK_SCRIPT = """
+import importlib.abc
+import importlib.machinery
+import sys
+import types
+
+FORBIDDEN = {forbidden!r}
+attempted = []
+
+
+class _Recorder(importlib.abc.MetaPathFinder, importlib.abc.Loader):
+    def find_spec(self, name, path, target=None):
+        if name.split(".")[0] in FORBIDDEN:
+            attempted.append(name.split(".")[0])
+            return importlib.machinery.ModuleSpec(name, self)
+        return None
+
+    def create_module(self, spec):
+        return types.ModuleType(spec.name)
+
+    def exec_module(self, module):
+        pass
+
+
+sys.meta_path.insert(0, _Recorder())
+import snowflake_sql_api  # noqa: F401
+print(",".join(sorted(set(attempted))))
+""".format(
+    forbidden=FORBIDDEN_ON_BARE_IMPORT
+)
+
+_TIMING_SCRIPT = """
+import time
+start = time.perf_counter()
+import snowflake_sql_api  # noqa: F401
+print(time.perf_counter() - start)
+"""
+
+
+def _run(script: str) -> subprocess.CompletedProcess:
+    return subprocess.run(
+        [sys.executable, "-c", script], capture_output=True, text=True
+    )
+
+
+def test_bare_import_pulls_no_heavy_deps() -> None:
+    result = _run(_LEAK_SCRIPT)
+    assert (
+        result.returncode == 0
+    ), f"`import snowflake_sql_api` failed in a clean subprocess:\n{result.stderr}"
+    attempted = [name for name in result.stdout.strip().split(",") if name]
+    assert not attempted, (
+        f"bare `import snowflake_sql_api` tried to import heavy deps: {attempted}. "
+        "Keep optional dependencies behind their extra (lazy import)."
+    )
+
+
+def test_bare_import_is_fast() -> None:
+    samples = []
+    for _ in range(TIMING_SAMPLES):
+        result = _run(_TIMING_SCRIPT)
+        assert result.returncode == 0, result.stderr
+        samples.append(float(result.stdout.strip()))
+    best = min(samples)
+    assert best < IMPORT_BUDGET_SECONDS, (
+        f"fastest of {TIMING_SAMPLES} imports was {best:.3f}s, over the "
+        f"{IMPORT_BUDGET_SECONDS}s budget. A heavy import likely crept into the "
+        "module-load path."
+    )

{snowflake_sql_api-0.1.0 → snowflake_sql_api-0.1.1}/tests/test_testing.py

@@ -46,6 +46,7 @@ def test_make_client_returns_real_client() -> None:
     assert isinstance(client, SnowflakeClient)
     assert client.query_scalar("SELECT 1") == 1
     client.close()
+    assert client._transport._client.is_closed
 
 
 def test_make_client_rejects_managed_kwargs() -> None:
@@ -304,6 +305,7 @@ async def test_async_query() -> None:
     assert isinstance(client, AsyncSnowflakeClient)
     assert await client.query("SELECT id FROM t") == [{"ID": 1}, {"ID": 2}]
     await client.aclose()
+    assert client._transport._client.is_closed
 
 
 async def test_async_submit_and_result() -> None: