190 lines
6.6 KiB
Python
190 lines
6.6 KiB
Python
import http.cookiejar
|
|
import http.client
|
|
import pathlib
|
|
import sys
|
|
import unittest
|
|
import urllib.error
|
|
|
|
|
|
ROOT = pathlib.Path(__file__).resolve().parents[2]
|
|
sys.path.insert(0, str(ROOT / "scripts"))
|
|
|
|
from lib.droboticflow_acceptance import DroboticflowClient, is_csrf_protected_method
|
|
|
|
|
|
class ClientError(RuntimeError):
|
|
pass
|
|
|
|
|
|
class FakeResponse:
|
|
def __init__(self, status=200, body=b"", headers=None):
|
|
self.status = status
|
|
self._body = body
|
|
self.headers = headers or {}
|
|
|
|
def __enter__(self):
|
|
return self
|
|
|
|
def __exit__(self, exc_type, exc, traceback):
|
|
return False
|
|
|
|
def read(self):
|
|
return self._body
|
|
|
|
def getcode(self):
|
|
return self.status
|
|
|
|
|
|
class FakeOpener:
|
|
def __init__(self, *responses):
|
|
self.responses = list(responses)
|
|
self.requests = []
|
|
self.timeouts = []
|
|
|
|
def open(self, request, timeout=0):
|
|
self.requests.append(request)
|
|
self.timeouts.append(timeout)
|
|
response = self.responses.pop(0)
|
|
if isinstance(response, BaseException):
|
|
raise response
|
|
return response
|
|
|
|
|
|
class PartialResponse(FakeResponse):
|
|
def read(self):
|
|
raise http.client.IncompleteRead(self._body)
|
|
|
|
|
|
def make_cookie(name, value):
|
|
return http.cookiejar.Cookie(
|
|
version=0,
|
|
name=name,
|
|
value=value,
|
|
port=None,
|
|
port_specified=False,
|
|
domain="api.example.test",
|
|
domain_specified=False,
|
|
domain_initial_dot=False,
|
|
path="/",
|
|
path_specified=True,
|
|
secure=False,
|
|
expires=None,
|
|
discard=True,
|
|
comment=None,
|
|
comment_url=None,
|
|
rest={},
|
|
rfc2109=False,
|
|
)
|
|
|
|
|
|
def request_headers(request):
|
|
return {key.lower(): value for key, value in request.header_items()}
|
|
|
|
|
|
class DroboticflowClientTest(unittest.TestCase):
|
|
def test_csrf_only_attaches_to_write_methods(self):
|
|
cookie_jar = http.cookiejar.CookieJar()
|
|
cookie_jar.set_cookie(make_cookie("droboticflow_csrf", "csrf%2Btoken"))
|
|
opener = FakeOpener(
|
|
FakeResponse(200, b'{"ok":true}'),
|
|
FakeResponse(200, b'{"ok":true}'),
|
|
)
|
|
client = DroboticflowClient(
|
|
"https://api.example.test/",
|
|
api_token="secret-token",
|
|
error_factory=ClientError,
|
|
cookie_jar=cookie_jar,
|
|
opener=opener,
|
|
)
|
|
|
|
post_response = client.request_json("POST", "/api/projects", {"name": "真实验收"})
|
|
get_response = client.request_json("GET", "/api/projects")
|
|
|
|
self.assertEqual(post_response, {"ok": True})
|
|
self.assertEqual(get_response, {"ok": True})
|
|
self.assertEqual(opener.requests[0].full_url, "https://api.example.test/api/projects")
|
|
self.assertEqual(opener.requests[0].data, b'{"name": "\xe7\x9c\x9f\xe5\xae\x9e\xe9\xaa\x8c\xe6\x94\xb6"}')
|
|
post_headers = request_headers(opener.requests[0])
|
|
self.assertEqual(post_headers["authorization"], "Bearer secret-token")
|
|
self.assertEqual(post_headers["x-droboticflow-csrf-token"], "csrf+token")
|
|
self.assertNotIn("x-droboticflow-csrf-token", request_headers(opener.requests[1]))
|
|
|
|
def test_request_bytes_preserves_binary_payload_and_headers(self):
|
|
opener = FakeOpener(FakeResponse(201, b"created", {"Location": "/object"}))
|
|
client = DroboticflowClient("https://api.example.test", opener=opener)
|
|
|
|
status, body, headers = client.request_bytes(
|
|
"POST",
|
|
"/api/object-storage/objects/upload",
|
|
body=b"\x00\x01payload",
|
|
headers={"Content-Type": "application/octet-stream"},
|
|
expected=(201,),
|
|
)
|
|
|
|
self.assertEqual(status, 201)
|
|
self.assertEqual(body, b"created")
|
|
self.assertEqual(headers["Location"], "/object")
|
|
self.assertEqual(opener.requests[0].data, b"\x00\x01payload")
|
|
self.assertEqual(request_headers(opener.requests[0])["content-type"], "application/octet-stream")
|
|
self.assertEqual(opener.timeouts[0], 300)
|
|
|
|
def test_complete_partial_chunk_body_is_preserved(self):
|
|
opener = FakeOpener(PartialResponse(200, b'{"ok":true}'))
|
|
client = DroboticflowClient("https://api.example.test", opener=opener)
|
|
|
|
self.assertEqual(client.request_json("POST", "/api/upload/complete", {}), {"ok": True})
|
|
|
|
def test_errors_use_script_specific_exception_type(self):
|
|
opener = FakeOpener(FakeResponse(500, b"boom"))
|
|
client = DroboticflowClient("https://api.example.test", error_factory=ClientError, opener=opener)
|
|
|
|
with self.assertRaisesRegex(ClientError, "POST /api/projects unexpected 500: boom"):
|
|
client.request_json("POST", "/api/projects", {})
|
|
|
|
def test_http_errors_use_script_specific_exception_type(self):
|
|
opener = FakeOpener(
|
|
urllib.error.HTTPError(
|
|
"https://api.example.test/api/projects",
|
|
403,
|
|
"forbidden",
|
|
{},
|
|
None,
|
|
)
|
|
)
|
|
client = DroboticflowClient("https://api.example.test", error_factory=ClientError, opener=opener)
|
|
|
|
with self.assertRaisesRegex(ClientError, "GET /api/projects failed 403"):
|
|
client.request_json("GET", "/api/projects")
|
|
|
|
def test_transient_url_errors_can_be_retried(self):
|
|
opener = FakeOpener(
|
|
urllib.error.URLError("temporary network issue"),
|
|
FakeResponse(200, b'{"ok":true}'),
|
|
)
|
|
client = DroboticflowClient("https://api.example.test", error_factory=ClientError, opener=opener)
|
|
|
|
response = client.request_json("GET", "/api/settings", retries=2, retry_delay_seconds=0)
|
|
|
|
self.assertEqual(response, {"ok": True})
|
|
self.assertEqual(len(opener.requests), 2)
|
|
self.assertEqual(opener.requests[1].full_url, "https://api.example.test/api/settings")
|
|
|
|
def test_login_if_configured_returns_authenticated_identifier(self):
|
|
opener = FakeOpener(FakeResponse(200, b'{"email":"admin@example.test"}'))
|
|
client = DroboticflowClient("https://api.example.test", opener=opener)
|
|
|
|
identifier = client.login_if_configured("admin@example.test", "password", label="test user")
|
|
|
|
self.assertEqual(identifier, "admin@example.test")
|
|
self.assertEqual(opener.requests[0].full_url, "https://api.example.test/api/auth/login")
|
|
|
|
def test_csrf_method_guard(self):
|
|
self.assertFalse(is_csrf_protected_method("GET"))
|
|
self.assertFalse(is_csrf_protected_method("head"))
|
|
self.assertTrue(is_csrf_protected_method("POST"))
|
|
self.assertTrue(is_csrf_protected_method("delete"))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|