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

95 lines
4.6 KiB
Python

import json
import pathlib
import socket
import sys
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
from rest_client.doubles import Served
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 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()