- responses.py: get_summary() (raw RPC get_summary), count_responses() -> frozen ResponseCounts(completed, incomplete, total), export_responses_auto() with automatic format fallback (xlsx -> xls -> csv) on IWriter errors - utils.py: summary_counts_full() -> (completed, incomplete, total) with per-LS-version key fallbacks; summary_counts left untouched - surveys.py: get_survey_by_sid() (dict | None), get_survey_info() -> frozen SurveyInfo(sid, title, active) - tokens.py: documented that extra/custom token attributes (attribute_1, ...) pass through unchanged in add_participants/list_participants - LsClient: get_summary, count_responses, get_survey_by_sid, get_survey_info, export_responses_auto; __all__ + re-exports updated - README: new "Response counts & summary" section + usage examples - .gitignore: prompts.md added (local-only docs, like werkdocument.md) - version 0.1.0 -> 0.2.0 (__init__.py + pyproject.toml) - tests: +27 FakeRpc unit tests (96 passed, 2 deselected) Generated by Mistral Vibe. Co-Authored-By: Mistral Vibe <vibe@mistral.ai>
214 lines
7.9 KiB
Python
214 lines
7.9 KiB
Python
"""Unit tests for pylimerpc.rpc.
|
|
|
|
Uses a stub HTTP server (stdlib http.server in a thread) — no real
|
|
LimeSurvey needed.
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import json
|
|
import logging
|
|
import socket
|
|
import threading
|
|
from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
|
|
from types import SimpleNamespace
|
|
from typing import Any
|
|
|
|
import pytest
|
|
|
|
from pylimerpc.errors import LsApiError, LsAuthError, LsConnectionError
|
|
from pylimerpc.rpc import endpoint_url, rpc_call
|
|
|
|
|
|
class _StubHandler(BaseHTTPRequestHandler):
|
|
def log_message(self, *args: Any) -> None: # keep test output quiet
|
|
pass
|
|
|
|
def _send_bytes(self, out: bytes, status: int, content_type: str) -> None:
|
|
self.send_response(status)
|
|
self.send_header("Content-Type", content_type)
|
|
self.send_header("Content-Length", str(len(out)))
|
|
self.end_headers()
|
|
self.wfile.write(out)
|
|
|
|
def _send_json(self, obj: dict, status: int = 200) -> None:
|
|
self._send_bytes(json.dumps(obj).encode("utf-8"), status, "application/json")
|
|
|
|
def do_POST(self) -> None:
|
|
length = int(self.headers.get("Content-Length") or 0)
|
|
body = self.rfile.read(length)
|
|
self.server.last_request = { # type: ignore[attr-defined]
|
|
"path": self.path,
|
|
"content_type": self.headers.get("Content-Type"),
|
|
"body": body,
|
|
}
|
|
try:
|
|
payload = json.loads(body.decode("utf-8"))
|
|
except json.JSONDecodeError:
|
|
payload = {}
|
|
method = payload.get("method")
|
|
rid = payload.get("id")
|
|
|
|
if self.path == "/http500":
|
|
self._send_bytes(b"<html><body><h1>500 Internal Server Error</h1></body></html>", 500, "text/html")
|
|
return
|
|
if self.path == "/badjson":
|
|
self._send_bytes(b"this is not valid json", 200, "application/json")
|
|
return
|
|
if method == "fail_api":
|
|
self._send_json({"jsonrpc": "2.0", "id": rid, "result": None, "error": {"code": -32602, "message": "Invalid params"}})
|
|
return
|
|
if method == "fail_auth":
|
|
self._send_json({"jsonrpc": "2.0", "id": rid, "result": None, "error": {"code": -32000, "message": "Invalid session key"}})
|
|
return
|
|
if method == "with_statistic":
|
|
self._send_json({"jsonrpc": "2.0", "id": rid, "result": {"ok": True}, "error": None, "statistic": {"duration_ms": 12, "memory": 2048}})
|
|
return
|
|
# default: echo of method + params
|
|
self._send_json({"jsonrpc": "2.0", "id": rid, "result": {"method": method, "params": payload.get("params")}, "error": None})
|
|
|
|
|
|
@pytest.fixture()
|
|
def stub():
|
|
server = ThreadingHTTPServer(("127.0.0.1", 0), _StubHandler)
|
|
thread = threading.Thread(target=server.serve_forever, daemon=True)
|
|
thread.start()
|
|
port = server.server_address[1]
|
|
yield SimpleNamespace(url=f"http://127.0.0.1:{port}", server=server)
|
|
server.shutdown()
|
|
server.server_close()
|
|
thread.join(timeout=5)
|
|
|
|
|
|
def test_rpc_call_succes_geeft_result_en_stuurt_juiste_request(stub):
|
|
result = rpc_call(f"{stub.url}/rpc", "echo", ["a", 1], timeout=5)
|
|
assert result == {"method": "echo", "params": ["a", 1]}
|
|
|
|
req = stub.server.last_request # type: ignore[attr-defined]
|
|
assert req["path"] == "/rpc"
|
|
assert req["content_type"] == "application/json"
|
|
sent = json.loads(req["body"].decode("utf-8"))
|
|
assert sent["jsonrpc"] == "2.0"
|
|
assert sent["method"] == "echo"
|
|
assert sent["params"] == ["a", 1]
|
|
assert isinstance(sent["id"], int)
|
|
|
|
|
|
def test_api_fout_wordt_lsapierror_met_diagnose(stub):
|
|
with pytest.raises(LsApiError) as excinfo:
|
|
rpc_call(f"{stub.url}/rpc", "fail_api", [123], timeout=5)
|
|
err = excinfo.value
|
|
assert not isinstance(err, LsAuthError)
|
|
assert err.rpc_code == -32602
|
|
assert err.rpc_message == "Invalid params"
|
|
assert err.method == "fail_api"
|
|
assert err.http_status == 200
|
|
assert err.raw == {"code": -32602, "message": "Invalid params"}
|
|
# method, params and body are in the message → diagnosable
|
|
assert "fail_api" in str(err)
|
|
assert "123" in str(err)
|
|
assert "Invalid params" in str(err)
|
|
|
|
|
|
def test_auth_fout_wordt_lsautherror(stub):
|
|
with pytest.raises(LsAuthError) as excinfo:
|
|
rpc_call(f"{stub.url}/rpc", "fail_auth", ["oude-key"], timeout=5)
|
|
err = excinfo.value
|
|
assert isinstance(err, LsApiError) # LsAuthError is a subtype
|
|
assert err.rpc_message == "Invalid session key"
|
|
|
|
|
|
def test_http_foutstatus_wordt_lsconnectionerror_met_body(stub):
|
|
with pytest.raises(LsConnectionError) as excinfo:
|
|
rpc_call(f"{stub.url}/http500", "echo", [], timeout=5)
|
|
err = excinfo.value
|
|
assert err.http_status == 500
|
|
assert "500" in str(err)
|
|
assert err.body is not None and "Internal Server Error" in err.body
|
|
assert err.cause is not None
|
|
|
|
|
|
def test_ongeldige_json_wordt_lsconnectionerror(stub):
|
|
with pytest.raises(LsConnectionError) as excinfo:
|
|
rpc_call(f"{stub.url}/badjson", "echo", [], timeout=5)
|
|
assert "no valid JSON" in str(excinfo.value)
|
|
assert excinfo.value.http_status == 200
|
|
|
|
|
|
def test_server_onbereikbaar_wordt_lsconnectionerror():
|
|
# find a free port and close it → connect is refused
|
|
sock = socket.socket()
|
|
sock.bind(("127.0.0.1", 0))
|
|
port = sock.getsockname()[1]
|
|
sock.close()
|
|
url = f"http://127.0.0.1:{port}/rpc"
|
|
with pytest.raises(LsConnectionError) as excinfo:
|
|
rpc_call(url, "echo", [], timeout=2)
|
|
assert excinfo.value.url == url
|
|
assert excinfo.value.cause is not None
|
|
assert excinfo.value.http_status is None
|
|
|
|
|
|
def test_statistic_veld_wordt_debug_gelogd(stub, caplog):
|
|
with caplog.at_level(logging.DEBUG, logger="pylimerpc.rpc"):
|
|
result = rpc_call(f"{stub.url}/rpc", "with_statistic", [], timeout=5)
|
|
assert result == {"ok": True}
|
|
assert any("statistic" in rec.getMessage().lower() and "duration_ms" in rec.getMessage() for rec in caplog.records)
|
|
|
|
|
|
def test_endpoint_url():
|
|
assert endpoint_url("https://host.nl/limesurvey") == "https://host.nl/limesurvey/index.php?r=admin/remotecontrol"
|
|
assert endpoint_url("https://host.nl/limesurvey/") == "https://host.nl/limesurvey/index.php?r=admin/remotecontrol"
|
|
assert endpoint_url("https://host.nl/index.php?r=admin/remotecontrol") == "https://host.nl/index.php?r=admin/remotecontrol"
|
|
|
|
|
|
def test_from_config_verify_ssl_false_maakt_ongeverifieerde_context():
|
|
import ssl
|
|
|
|
from pylimerpc.config import LsConfig
|
|
from pylimerpc.rpc import RpcClient
|
|
|
|
cfg = LsConfig(
|
|
base_url="https://ls.example.com/index.php?r=admin/remotecontrol",
|
|
username="u",
|
|
password="p",
|
|
verify_ssl=False,
|
|
)
|
|
client = RpcClient.from_config(cfg)
|
|
assert client.ssl_context is not None
|
|
assert client.ssl_context.verify_mode == ssl.CERT_NONE
|
|
assert client.ssl_context.check_hostname is False
|
|
|
|
# default (verify_ssl=True) → None = urllib's standard verifying context
|
|
cfg_ok = LsConfig(base_url="https://ls.example.com/index.php?r=admin/remotecontrol", username="u", password="p")
|
|
assert RpcClient.from_config(cfg_ok).ssl_context is None
|
|
|
|
|
|
def test_rpc_call_geeft_ssl_context_en_timeout_door_aan_urlopen(monkeypatch, stub):
|
|
import ssl
|
|
import urllib.request
|
|
|
|
captured: dict = {}
|
|
|
|
class FakeResp:
|
|
status = 200
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, *args):
|
|
return False
|
|
|
|
def read(self):
|
|
return json.dumps({"jsonrpc": "2.0", "id": 1, "result": "ok", "error": None}).encode()
|
|
|
|
def fake_urlopen(req, timeout=None, context=None, **kwargs):
|
|
captured["timeout"] = timeout
|
|
captured["context"] = context
|
|
return FakeResp()
|
|
|
|
monkeypatch.setattr(urllib.request, "urlopen", fake_urlopen)
|
|
ctx = ssl.create_default_context()
|
|
assert rpc_call(f"{stub.url}/rpc", "echo", [], timeout=7, ssl_context=ctx) == "ok"
|
|
assert captured["timeout"] == 7
|
|
assert captured["context"] is ctx
|