Files
claude-config/bin/rest_client/test_json_request.py
T

142 lines
6.1 KiB
Python

import http.server
import json
import pathlib
import socket
import sys
import threading
import unittest
sys.path.insert(0, str(pathlib.Path(__file__).resolve().parents[1]))
from rest_client.json_request import ErrorAnswer
from failure import Failure
from rest_client import json_request
def message(answer: object) -> str:
return answer.get("message", "") if isinstance(answer, dict) else ""
def send(method: str, url: str, token: str, body: object, seconds: float = 5) -> object:
return json_request.http_json(method, url, f"Bearer {token}", body, seconds, message) # type: ignore[arg-type]
class Recorded(http.server.BaseHTTPRequestHandler):
"""Answers each request with the server's next scripted status and body, recording what it got."""
def do_GET(self) -> None:
self.answer()
def do_POST(self) -> None:
self.answer()
def do_PUT(self) -> None:
self.answer()
def answer(self) -> None:
length = int(self.headers.get("Content-Length") or 0)
self.server.got.append((self.command, self.path, dict(self.headers), self.rfile.read(length))) # type: ignore[attr-defined]
status, body = self.server.script.pop(0) # type: ignore[attr-defined]
if status is None:
# Raw bytes, as a server that breaks HTTP sends them.
self.wfile.write(body)
self.close_connection = True
return
self.send_response(status)
if 300 <= status < 400:
self.send_header("Location", "/elsewhere")
self.send_header("Content-Type", "application/json")
self.end_headers()
self.wfile.write(body)
def log_message(self, format: str, *args: object) -> None:
pass
class Served(unittest.TestCase):
"""A test case with a local server that answers by a script; it holds no test itself, so a test elsewhere may build on it."""
def serve(self, *script: tuple[int, bytes]) -> str:
server = http.server.HTTPServer(("127.0.0.1", 0), Recorded)
server.script = list(script) # type: ignore[attr-defined]
server.got = [] # type: ignore[attr-defined]
threading.Thread(target=server.serve_forever, daemon=True).start()
self.addCleanup(server.server_close)
self.addCleanup(server.shutdown)
self.server = server
return f"http://127.0.0.1:{server.server_port}"
class HttpJson(Served):
def test_sends_the_authorization_and_the_body_as_json_and_reads_the_json_answer(self):
base = self.serve((201, b'{"id": "post-id"}'))
self.assertEqual(send("POST", f"{base}/api/v4/posts", "secret-token", {"message": "hi"}), {"id": "post-id"})
[(method, path, headers, body)] = self.server.got # type: ignore[attr-defined]
self.assertEqual((method, path, headers["Authorization"], headers["Content-Type"], headers["Accept"], json.loads(body)), ("POST", "/api/v4/posts", "Bearer secret-token", "application/json", "application/json", {"message": "hi"}))
def test_reads_an_answer_without_a_body_as_none(self):
for body in (b"", b"\n"):
with self.subTest(body=body):
base = self.serve((201, body))
self.assertIsNone(send("POST", f"{base}/rest/api/3/issueLink", "t", {"type": {"name": "Blocks"}}))
def test_names_the_request_the_status_and_the_apis_message_on_an_error(self):
base = self.serve((401, b'{"message": "Invalid or expired session, please login again."}'))
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "bad", None), ErrorAnswer("GET /api/v4/users/me answered 401: Invalid or expired session, please login again.", 401))
def test_follows_no_redirect_so_the_token_goes_only_to_the_server_named(self):
base = self.serve((302, b"{}"))
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), ErrorAnswer("GET /api/v4/users/me answered 302: Found", 302))
self.assertEqual(len(self.server.got), 1) # type: ignore[attr-defined]
def test_sends_no_body_with_a_get(self):
base = self.serve((200, b'{"id": "bot-id"}'))
send("GET", f"{base}/api/v4/users/me", "t", None)
[(_, _, headers, body)] = self.server.got # type: ignore[attr-defined]
self.assertEqual((headers.get("Content-Length"), body), (None, b""))
def test_fails_on_an_answer_that_breaks_http(self):
for raw in (b"garbage\r\n\r\n", b"HTTP/1.1 200 OK\r\nContent-Length: 100\r\n\r\n{}"):
with self.subTest(raw=raw):
base = self.serve((None, raw))
failed = send("GET", f"{base}/api/v4/users/me", "t", None)
self.assertTrue(isinstance(failed, Failure) and failed.reason.startswith("GET /api/v4/users/me got a broken answer: "), failed)
def test_names_the_status_of_an_error_whose_body_is_cut_short(self):
base = self.serve((None, b"HTTP/1.1 500 Internal Server Error\r\nContent-Length: 100\r\n\r\n{}"))
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), ErrorAnswer("GET /api/v4/users/me answered 500: Internal Server Error", 500))
def test_gives_up_on_a_server_that_never_answers_after_the_timeout(self):
silent = socket.socket()
self.addCleanup(silent.close)
silent.bind(("127.0.0.1", 0))
silent.listen(1)
base = f"http://127.0.0.1:{silent.getsockname()[1]}"
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None, 0.2), Failure(f"cannot reach {base}: timed out"))
def test_fails_on_an_answer_that_is_not_json(self):
base = self.serve((200, b"<html>"))
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), Failure("GET /api/v4/users/me answered with something other than JSON"))
def test_fails_naming_the_server_it_cannot_reach(self):
base = self.serve()
self.server.server_close()
failed = send("GET", f"{base}/api/v4/users/me", "t", None)
self.assertIsInstance(failed, Failure)
self.assertTrue(str(getattr(failed, "reason", "")).startswith(f"cannot reach {base}: "), failed)
def test_names_why_a_server_refuses_the_connection(self):
with socket.socket() as taken:
taken.bind(("127.0.0.1", 0))
port = taken.getsockname()[1]
failed = send("GET", f"http://127.0.0.1:{port}/api", "t", None)
self.assertEqual(failed, Failure(f"cannot reach http://127.0.0.1:{port}: [Errno 111] Connection refused"))
def test_an_error_whose_body_is_not_json_names_the_status_alone(self):
base = self.serve((403, b"<html>"))
self.assertEqual(send("GET", f"{base}/api/v4/users/me", "t", None), ErrorAnswer("GET /api/v4/users/me answered 403: Forbidden", 403))
if __name__ == "__main__":
unittest.main()