142 lines
6.1 KiB
Python
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()
|