Files
DataStack/tests/phase05_sdk_test.py
T
Team Dark Devil 177ed4a844 refactor(auth): standardize session management and security
- Centralize secret retrieval using `getAdminSessionSecret`
- Replace manual session parsing with `verifyRequestAdminSession` utility
- Tighten API validation and improve security headers handling
- Enforce environment variable security for production deployments
2026-11-18 05:18:55 +06:00

267 lines
11 KiB
Python

"""
Phase-05 Verification Tests (BUG-18):
- Single Source of Truth between canonical `datastack` (`sdk/python/datastack`)
and compatibility alias `datastack_sdk` (`sdk-python`).
- `CLIENT_ID` config loading (`config.datastack.py`, `DATASTACK_CLIENT_ID`, kwarg),
JWT `clientId`/`sub` fallback extraction, and mismatch validation.
- End-to-end propagation of `clientId` & `X-DataStack-Client-Id` into HTTP
fallback ingestion (`send`, `send_batch`, `send_file`), status snapshot, and
offline disk spool replay against a local HTTP test server.
"""
import base64
import json
import os
import sys
import tempfile
import threading
import unittest
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
from pathlib import Path
from typing import Any, Dict, List
REPO_ROOT = Path(__file__).resolve().parents[1]
CANONICAL_PKG_ROOT = REPO_ROOT / "sdk" / "python" / "datastack"
COMPAT_PKG_ROOT = REPO_ROOT / "sdk-python"
for p in (str(CANONICAL_PKG_ROOT), str(COMPAT_PKG_ROOT)):
if p not in sys.path:
sys.path.insert(0, p)
import datastack # noqa: E402
import datastack_sdk # noqa: E402
from datastack import ( # noqa: E402
DataStack,
DataStackClient,
DataStackConfig,
DataStackConfigError,
DataStackOfflineSpoolError,
DiskSpooler,
HeartbeatMonitor,
load_config,
)
def _make_jwt(payload: Dict[str, Any]) -> str:
header = (
base64.urlsafe_b64encode(json.dumps({"alg": "HS256", "typ": "JWT"}).encode())
.decode()
.rstrip("=")
)
body = (
base64.urlsafe_b64encode(json.dumps(payload).encode())
.decode()
.rstrip("=")
)
return f"{header}.{body}.testsig"
class Phase05PythonSdkTests(unittest.TestCase):
def test_single_source_of_truth_identity(self) -> None:
self.assertIs(datastack_sdk.DataStack, datastack.DataStack)
self.assertIs(datastack_sdk.DataStackClient, datastack.DataStackClient)
self.assertIs(datastack_sdk.DataStackConfig, datastack.DataStackConfig)
self.assertIs(datastack_sdk.load_config, datastack.load_config)
self.assertIs(
datastack_sdk.DataStackConfigError, datastack.DataStackConfigError
)
self.assertIs(
datastack_sdk.DataStackOfflineSpoolError,
datastack.DataStackOfflineSpoolError,
)
self.assertIs(datastack_sdk.DiskSpooler, datastack.DiskSpooler)
self.assertIs(datastack_sdk.HeartbeatMonitor, datastack.HeartbeatMonitor)
self.assertEqual(datastack_sdk.__version__, datastack.__version__)
# Submodule shims also resolve to canonical classes
from datastack_sdk.client import DataStackClient as ShimClient
from datastack_sdk.config import load_config as shim_load_config
from datastack_sdk.exceptions import (
DataStackOfflineSpoolError as ShimSpoolErr,
)
self.assertIs(ShimClient, DataStackClient)
self.assertIs(shim_load_config, load_config)
self.assertIs(ShimSpoolErr, DataStackOfflineSpoolError)
def test_client_id_config_env_and_jwt_validation(self) -> None:
tok_alpha = _make_jwt({"clientId": "alpha_svc", "sub": "alpha_svc"})
with tempfile.TemporaryDirectory() as tmpdir:
cfg_file = Path(tmpdir) / "config.datastack.py"
cfg_file.write_text(
f'DATASTACK_CONFIG = {{\n'
f' "SERVER_URL": "http://127.0.0.1:49999",\n'
f' "API_URL": "http://127.0.0.1:39999",\n'
f' "CLIENT_TOKEN": "{tok_alpha}",\n'
f' "CLIENT_ID": "alpha_svc",\n'
f' "AUTO_CONNECT": False,\n'
f' "OFFLINE_SPOOL_DIR": "{Path(tmpdir) / "spool"}",\n'
f'}}\n',
encoding="utf-8",
)
cfg = load_config(config_path=str(cfg_file))
self.assertIsInstance(cfg, DataStackConfig)
self.assertEqual(cfg.client_id, "alpha_svc")
# Matching explicit client_id succeeds
client = DataStack(config_path=str(cfg_file), auto_connect=False)
self.assertEqual(client.client_id, "alpha_svc")
self.assertEqual(client.status()["clientId"], "alpha_svc")
client.disconnect()
# Env override matching JWT succeeds; mismatching raises DataStackConfigError
old_env = os.environ.get("DATASTACK_CLIENT_ID")
try:
os.environ["DATASTACK_CLIENT_ID"] = "wrong_svc"
with self.assertRaises(DataStackConfigError):
DataStack(config_path=str(cfg_file), auto_connect=False)
finally:
if old_env is None:
os.environ.pop("DATASTACK_CLIENT_ID", None)
else:
os.environ["DATASTACK_CLIENT_ID"] = old_env
# Mismatched kwarg client_id raises DataStackConfigError
with self.assertRaises(DataStackConfigError):
DataStack(
config_path=str(cfg_file),
client_id="mismatch_svc",
auto_connect=False,
)
# Auto-derives client_id from JWT when CLIENT_ID is omitted
tok_derived = _make_jwt({"sub": "derived_worker"})
derived_client = DataStack(
server_url="http://127.0.0.1:49999",
api_url="http://127.0.0.1:39999",
token=tok_derived,
auto_connect=False,
)
self.assertEqual(derived_client.client_id, "derived_worker")
self.assertEqual(derived_client.status()["clientId"], "derived_worker")
derived_client.disconnect()
def test_http_fallback_and_offline_spool_carry_client_id(self) -> None:
recorded_requests: List[Dict[str, Any]] = []
tok = _make_jwt({"clientId": "sensor_01", "sub": "sensor_01"})
class MockHandler(BaseHTTPRequestHandler):
def do_GET(self) -> None: # noqa: N802
if self.path == "/api/health":
body = json.dumps({"status": "online"}).encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
return
self.send_response(404)
self.end_headers()
def do_POST(self) -> None: # noqa: N802
length = int(self.headers.get("Content-Length", "0"))
raw = self.rfile.read(length).decode("utf-8")
parsed = json.loads(raw) if raw else {}
recorded_requests.append(
{
"path": self.path,
"client_id_header": self.headers.get("X-DataStack-Client-Id"),
"auth": self.headers.get("Authorization"),
"body": parsed,
}
)
resp_payload: Dict[str, Any] = {"success": True}
if isinstance(parsed, dict) and "batch" in parsed:
resp_payload["processed"] = len(parsed["batch"])
resp_payload["rejected"] = 0
elif isinstance(parsed, dict) and "records" in parsed:
resp_payload["processed"] = len(parsed["records"])
resp_payload["rejected"] = 0
body = json.dumps(resp_payload).encode("utf-8")
self.send_response(200)
self.send_header("Content-Type", "application/json")
self.send_header("Content-Length", str(len(body)))
self.end_headers()
self.wfile.write(body)
def log_message(self, format: str, *args: Any) -> None:
return
server = ThreadingHTTPServer(("127.0.0.1", 0), MockHandler)
port = server.server_address[1]
thread = threading.Thread(target=server.serve_forever, daemon=True)
thread.start()
try:
with tempfile.TemporaryDirectory() as tmpdir:
spool_dir = Path(tmpdir) / "spool"
csv_file = Path(tmpdir) / "sample.csv"
csv_file.write_text("temp,unit\n21.5,C\n22.0,C\n", encoding="utf-8")
client = DataStack(
server_url="http://127.0.0.1:1", # unreachable WS -> HTTP fallback
api_url=f"http://127.0.0.1:{port}",
token=tok,
client_id="sensor_01",
auto_connect=False,
request_timeout_sec=1.0,
max_retries=0,
offline_spool_dir=str(spool_dir),
)
# Single event via HTTP fallback
res_single = client.send({"reading": 42})
self.assertTrue(res_single.get("success"))
self.assertEqual(res_single.get("transport"), "HTTP_FALLBACK")
# Batch events via HTTP fallback
res_batch = client.send_batch([{"k": "a"}, {"k": "b"}])
self.assertEqual(res_batch.get("processed"), 2)
# File ingestion via HTTP fallback
res_file = client.send_file(csv_file)
self.assertEqual(res_file.get("processed"), 2)
client.disconnect()
self.assertEqual(len(recorded_requests), 3)
for req in recorded_requests:
self.assertEqual(req["path"], "/api/events")
self.assertEqual(req["client_id_header"], "sensor_01")
self.assertEqual(req["auth"], f"Bearer {tok}")
self.assertEqual(recorded_requests[0]["body"]["clientId"], "sensor_01")
self.assertEqual(
[r["clientId"] for r in recorded_requests[1]["body"]["batch"]],
["sensor_01", "sensor_01"],
)
self.assertEqual(
[r["clientId"] for r in recorded_requests[2]["body"]["records"]],
["sensor_01", "sensor_01"],
)
# Offline spool check when HTTP is also unreachable
offline_client = datastack_sdk.DataStackClient(
server_url="http://127.0.0.1:1",
api_url="http://127.0.0.1:1",
token=tok,
auto_connect=False,
request_timeout_sec=1.0,
max_retries=0,
offline_spool_dir=str(spool_dir),
)
spool_res = offline_client.send({"offline_metric": 99})
offline_client.disconnect()
self.assertTrue(spool_res.get("spooled"))
self.assertEqual(spool_res.get("transport"), "OFFLINE_SPOOL")
self.assertGreaterEqual(spool_res.get("spooledCount", 0), 1)
finally:
server.shutdown()
server.server_close()
if __name__ == "__main__":
unittest.main(verbosity=2)