withruntime 0.6.1__tar.gz → 0.7.0__tar.gz

{withruntime-0.6.1/withruntime.egg-info → withruntime-0.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: withruntime
-Version: 0.6.1
+Version: 0.7.0
 Summary: Runtime Cloud: one client (sync and async) for every Runtime product. Sandboxes first.
 License: Apache-2.0
 Requires-Python: >=3.10
@@ -43,7 +43,7 @@ with Sandbox.create() as sbx:
 
 `Sandbox.create()` needs no arguments and returns once the sandbox is running;
 leaving the `with` block stops it. With no arguments you get the free trial
-while it lasts: 50 free hours, no card, up to eight sandboxes running at once.
+while it lasts: 100 free hours, no card, up to eight sandboxes running at once.
 The current default image includes NumPy, pandas and matplotlib; see the
 [sandbox environment](https://withruntime.com/docs/sandbox-environment).
 `AsyncRuntime` is the same client for asyncio, method for method:

{withruntime-0.6.1 → withruntime-0.7.0}/README.md

@@ -25,7 +25,7 @@ with Sandbox.create() as sbx:
 
 `Sandbox.create()` needs no arguments and returns once the sandbox is running;
 leaving the `with` block stops it. With no arguments you get the free trial
-while it lasts: 50 free hours, no card, up to eight sandboxes running at once.
+while it lasts: 100 free hours, no card, up to eight sandboxes running at once.
 The current default image includes NumPy, pandas and matplotlib; see the
 [sandbox environment](https://withruntime.com/docs/sandbox-environment).
 `AsyncRuntime` is the same client for asyncio, method for method:

{withruntime-0.6.1 → withruntime-0.7.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "withruntime"
-version = "0.6.1"
+version = "0.7.0"
 description = "Runtime Cloud: one client (sync and async) for every Runtime product. Sandboxes first."
 readme = "README.md"
 license = { text = "Apache-2.0" }

withruntime-0.7.0/tests/test_account_errors.py

@@ -0,0 +1,46 @@
+"""A blocked account gets its own error type (ARCHITECTURE.md section 11,
+"A blocked account is told why")."""
+
+import unittest
+from typing import Any
+
+import withruntime
+from withruntime._errors import error_for
+
+
+class AccountErrorsTest(unittest.TestCase):
+    def test_account_blocked_is_its_own_type(self) -> None:
+        error = error_for(402, {"error": {"code": "account_blocked",
+                                          "message": "This account cannot spend: a payment on it is disputed."}}, None)
+        self.assertIsInstance(error, withruntime.AccountBlockedError)
+        self.assertIsInstance(error, withruntime.RuntimeError)
+        self.assertEqual(error.code, "account_blocked")
+        self.assertEqual(error.status, 402)
+        self.assertFalse(error.retryable)
+
+    def test_empty_balance_stays_plain(self) -> None:
+        error = error_for(402, {"error": {"code": "insufficient_funds", "message": "Add credit."}}, None)
+        self.assertNotIsInstance(error, withruntime.AccountBlockedError)
+
+
+class AccountCloseTest(unittest.TestCase):
+    """runtime.account.close (ARCHITECTURE.md section 3.1)."""
+
+    def test_close_posts_the_typed_name_once(self) -> None:
+        from withruntime._sync_client import Account
+
+        calls: list[tuple[Any, ...]] = []
+
+        class Transport:
+            def json(self, method: str, path: str, **kwargs: Any) -> dict[str, Any]:
+                calls.append((method, path, kwargs))
+                return {"orgId": "o1", "name": "Acme", "closedAt": "2026-09-25T20:00:00Z", "released": True}
+
+        closed = Account(Transport()).close(confirm="Acme")  # type: ignore[arg-type]
+        self.assertTrue(closed["released"])
+        self.assertEqual(calls, [("POST", "/v1/account:close", {"body": {"confirm": "Acme"}, "retry": False})])
+        self.assertTrue(hasattr(withruntime.Runtime(api_key="rk_x"), "account"))
+
+
+if __name__ == "__main__":
+    unittest.main()

withruntime-0.7.0/tests/test_billing.py

@@ -0,0 +1,72 @@
+"""runtime.billing.topup() and topup_status() against a stub API, sync and
+async. The route is tested in packages/cloud (billing-api)."""
+import asyncio
+import json
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from withruntime import AsyncRuntime, Runtime
+
+TOPUP = {
+    "purchaseId": "3f0c2a4e-1b7d-4c5a-9e2f-0a1b2c3d4e5f",
+    "status": "open",
+    "amountUsd": "20.00",
+    "amount": "20.000000",
+    "payBy": "2026-09-25T13:00:00.000Z",
+    "networks": [{"network": "base", "address": "0xbase", "tokens": [{"currency": "usdc", "contract": "0xusdc"}]}],
+}
+
+
+class Stub(BaseHTTPRequestHandler):
+    seen: list = []
+
+    def log_message(self, *args):
+        pass
+
+    def answer(self):
+        length = int(self.headers.get("content-length") or 0)
+        body = json.loads(self.rfile.read(length)) if length else None
+        Stub.seen.append((self.command, self.path, body, self.headers.get("idempotency-key")))
+        data = json.dumps(TOPUP).encode()
+        self.send_response(200)
+        self.send_header("content-type", "application/json")
+        self.send_header("content-length", str(len(data)))
+        self.end_headers()
+        self.wfile.write(data)
+
+    do_GET = answer
+    do_POST = answer
+
+
+class BillingTest(unittest.TestCase):
+    @classmethod
+    def setUpClass(cls):
+        cls.server = ThreadingHTTPServer(("127.0.0.1", 0), Stub)
+        threading.Thread(target=cls.server.serve_forever, daemon=True).start()
+        cls.url = f"http://127.0.0.1:{cls.server.server_address[1]}"
+
+    @classmethod
+    def tearDownClass(cls):
+        cls.server.shutdown()
+
+    def setUp(self):
+        Stub.seen = []
+
+    def test_sync_topup_and_status(self):
+        with Runtime(api_key="rk_test", base_url=self.url, max_retries=0) as runtime:
+            self.assertEqual(runtime.billing.topup(20, idempotency_key="k1")["amount"], "20.000000")
+            self.assertEqual(runtime.billing.topup_status(TOPUP["purchaseId"])["status"], "open")
+        self.assertEqual(Stub.seen[0], ("POST", "/v1/billing/topups", {"usd": 20}, "k1"))
+        self.assertEqual(Stub.seen[1][:2], ("GET", f"/v1/billing/topups/{TOPUP['purchaseId']}"))
+
+    def test_async_topup(self):
+        async def go():
+            async with AsyncRuntime(api_key="rk_test", base_url=self.url, max_retries=0) as runtime:
+                return await runtime.billing.topup(20)
+
+        self.assertEqual(asyncio.run(go())["networks"][0]["address"], "0xbase")
+
+
+if __name__ == "__main__":
+    unittest.main()

{withruntime-0.6.1 → withruntime-0.7.0}/tests/test_capacity_wait.py

@@ -84,6 +84,15 @@ class CapacityWait(unittest.TestCase):
             self.assertEqual(len(set(wire.bodies)), 1)
             self.assertEqual(json.loads(wire.bodies[0]), {"funding": "trial", "labels": {"ci": "1"}})
 
+    def test_a_create_says_why_it_waits_before_each_wait(self):
+        heard = []
+        busy = refusal("trial_busy")
+        for _, outcome, _ in create([busy, busy], on_capacity_wait=lambda error, seconds: heard.append(
+                (error.code, seconds))):
+            self.assertEqual(outcome.id, "sbx")
+        # Sync, then async: two waits each, of retryAfterMs.
+        self.assertEqual(heard, [("trial_busy", 0.005)] * 4)
+
     def test_the_paid_limit_a_domain_limit_and_a_full_region_are_waited_out_too(self):
         for code in ("quota_exceeded", "trial_domain_limit", "no_capacity"):
             for wire, outcome, _ in create([refusal(code)]):

{withruntime-0.6.1 → withruntime-0.7.0}/tests/test_client.py

@@ -83,8 +83,10 @@ class Sync(unittest.TestCase):
         self.assertEqual(seen, ["hello\n"])
 
     def test_errors_are_typed_and_keys_never_leak(self):
+        # A misspelled field is refused before sending (test_exec_stream.CreateFields);
+        # a value out of range is the API's to refuse.
         with self.assertRaises(InvalidRequestError) as caught:
-            client().sandboxes.create(vcpus=2)
+            client().sandboxes.create(vcpu=0)
         self.assertIn("issues", caught.exception.details)
         self.assertNotIn("rk_test", str(caught.exception))
         self.assertTrue(ServiceUnavailableError("x", status=503).retryable)

{withruntime-0.6.1 → withruntime-0.7.0}/tests/test_e2b_sandbox.py

@@ -340,11 +340,15 @@ class ForksPortsAndGaps(Base):
             self.assertEqual(caught.exception.code, "fork_unavailable")
 
     def test_ports(self):
+        # 25 September 2026: get_host raised, so E2B code did not run unchanged.
         sbx = self.create()
-        with self.assertRaises(NotSupportedException) as caught:
-            sbx.get_host(3000)
-        self.assertIn("get_public_host", str(caught.exception))
-        self.assertEqual(sbx.get_public_host(3000), f"3000-{sbx.sandbox_id}.runtimehost.com")
+        host = f"3000-{sbx.sandbox_id.replace('-', '')}.runtimehost.com"
+        self.assertEqual(sbx.get_host(3000), host)
+        self.assertEqual(sbx.get_host(3000), host)
+        self.assertEqual(sbx.get_public_host(3000), host)
+        self.assertEqual(len(self.world.called("previews.create")), 1)
+        with self.assertRaises(e2b.InvalidArgumentException):
+            sbx.get_host(0)
 
     def test_gaps(self):
         sbx = self.create()
@@ -356,6 +360,17 @@ class ForksPortsAndGaps(Base):
 
 
 class Async(unittest.TestCase):
+    def test_get_host_answers_at_once_and_the_share_lands_beside_it(self):
+        world = World()
+
+        async def scenario():
+            async with await AsyncSandbox.create(client=world.async_client()) as sbx:
+                host = sbx.get_host(8000)  # no await, as in E2B
+                self.assertEqual(host, f"8000-{sbx.sandbox_id.replace('-', '')}.runtimehost.com")
+                self.assertEqual(await sbx.get_public_host(8000), host)
+                self.assertEqual(len(world.called("previews.create")), 1)
+        asyncio.run(scenario())
+
     def test_async_sandbox_end_to_end(self):
         world = World()
 

withruntime-0.7.0/tests/test_eval_sandbox.py

@@ -0,0 +1,43 @@
+"""Exit codes in withruntime._eval_sandbox, which Harbor and Inspect share, as the
+live API reports them (read on 25 September 2026): a command past its limit ends
+with -9 and timedOut, and a command a signal ended with the negative signal
+number. Harbor and Inspect expect what a shell reports. Needs neither."""
+import asyncio
+import unittest
+
+from withruntime._eval_sandbox import _Shell, shell_exit_code
+
+
+class _Sandbox:
+    id = "sbx_exit"
+
+    def __init__(self, exit_event):
+        self.exit_event = exit_event
+
+    async def exec_stream(self, argv, *, env=None, stdin=None, timeout_ms=None):
+        yield {"type": "start", "processId": "p1"}
+        yield self.exit_event
+
+
+def _run(exit_event):
+    shell = _Shell(_Sandbox(exit_event), "/tmp")
+    return asyncio.run(shell._stream(["sh", "-c", "x"], None, None, 1000, None, None))
+
+
+class ShellExitCodeTest(unittest.TestCase):
+    def test_a_timed_out_command_is_124(self):
+        result = _run({"type": "exit", "exitCode": -9, "state": "timed_out", "timedOut": True})
+        self.assertEqual((result.exit_code, result.timed_out), (124, True))
+
+    def test_a_command_a_signal_ended_is_128_plus_the_signal(self):
+        self.assertEqual(_run({"type": "exit", "exitCode": -15, "timedOut": False}).exit_code, 143)
+        self.assertEqual(_run({"type": "exit", "exitCode": -9, "timedOut": False}).exit_code, 137)
+
+    def test_ordinary_codes_are_kept(self):
+        self.assertEqual(_run({"type": "exit", "exitCode": 3, "timedOut": False}).exit_code, 3)
+        self.assertEqual(shell_exit_code(0, False), 0)
+        self.assertEqual(shell_exit_code(None, False), -1)
+
+
+if __name__ == "__main__":
+    unittest.main()

withruntime-0.7.0/tests/test_exec_stream.py

@@ -0,0 +1,131 @@
+"""A streamed exec that loses output or its connection (user lane, 25 September
+2026): lost output never passes as whole, and a connection cut after the command
+started does not end the command's output. Sync and async share the code, so
+both are driven here over a fake wire."""
+import asyncio
+import json
+import unittest
+
+from withruntime import AsyncRuntime, ConnectionError, Runtime
+
+ID = "8a1f9c2e-0d1b-4c3a-9e8f-7a6b5c4d3e2f"
+INFO = json.dumps({"id": ID, "kind": "sandbox", "state": "running", "status": "active"}).encode()
+
+
+class Wire:
+    """Answers each path with scripted NDJSON lines, then an end or a failure."""
+
+    def __init__(self, routes, is_async):
+        self.routes, self.is_async, self.targets = routes, is_async, []
+
+    def send(self, method, target, headers, data, timeout):
+        self.targets.append(f"{method} {target}")
+        lines, fail = next(((lines, fail) for suffix, (lines, fail) in self.routes.items()
+                            if target.split("?")[0].endswith(suffix)), ([], False))
+        body = [json.dumps(line) for line in lines]
+        is_async = self.is_async
+
+        class Answer:
+            status, headers = 200, {}
+
+            if is_async:
+                async def read(self):
+                    return INFO
+
+                async def lines(self):
+                    for line in body:
+                        yield line
+                    if fail:
+                        raise OSError("connection reset")
+
+                async def close(self):
+                    return None
+            else:
+                def read(self):
+                    return INFO
+
+                def lines(self):
+                    yield from body
+                    if fail:
+                        raise OSError("connection reset")
+
+                def close(self):
+                    return None
+        answer = Answer()
+        if self.is_async:
+            async def later():
+                return answer
+            return later()
+        return answer
+
+
+def run_exec(routes):
+    """One streamed exec, sync and async: each run's wire and outcome."""
+    runs = []
+    for is_async in (False, True):
+        wire = Wire(routes, is_async)
+        runtime = (AsyncRuntime if is_async else Runtime)(api_key="rk", base_url="https://api.example.test")
+        runtime._t._http = wire
+
+        def call():
+            if is_async:
+                async def go():
+                    sbx = await runtime.sandboxes.get(ID)
+                    return await sbx.exec("x", on_stdout=lambda _: None)
+                return asyncio.run(go())
+            return runtime.sandboxes.get(ID).exec("x", on_stdout=lambda _: None)
+        try:
+            outcome = call()
+        except Exception as error:  # noqa: BLE001 - the outcome under test
+            outcome = error
+        runs.append((wire, outcome))
+    return runs
+
+
+EXIT = {"type": "exit", "exitCode": 0, "state": "exited", "timedOut": False}
+
+
+class ExecStream(unittest.TestCase):
+    def test_output_the_stream_skipped_is_reported_lost_even_unnamed(self):
+        routes = {":exec": ([{"type": "start", "processId": "p1"}, {"type": "stdout", "data": "a\n", "offset": 0},
+                             {"type": "stdout", "data": "b\n", "offset": 10}, EXIT], False)}
+        for _, result in run_exec(routes):
+            self.assertEqual(result.exit_code, 0)
+            self.assertEqual(result.stdout, "a\nb\n")
+            self.assertTrue(result.stdout_truncated)
+
+    def test_a_cut_after_the_start_is_followed_from_where_it_stopped(self):
+        routes = {":exec": ([{"type": "start", "processId": "p1"}, {"type": "stdout", "data": "a\n", "offset": 0}], True),
+                  "/processes/p1/output": ([{"type": "stdout", "data": "b\n", "offset": 2}, EXIT], False)}
+        for wire, result in run_exec(routes):
+            self.assertEqual(result.stdout, "a\nb\n")
+            self.assertFalse(result.stdout_truncated)
+            self.assertIn(f"GET /v1/sandboxes/{ID}/processes/p1/output?cursor=2&follow=true", wire.targets)
+
+    def test_a_stream_that_keeps_closing_is_given_up_naming_the_process(self):
+        routes = {":exec": ([{"type": "start", "processId": "p1"}], False), "/processes/p1/output": ([], False)}
+        for wire, error in run_exec(routes):
+            self.assertIsInstance(error, ConnectionError)
+            self.assertEqual(error.details, {"sandboxId": ID, "processId": "p1"})
+            self.assertEqual(sum("/output" in t for t in wire.targets), 4)
+
+
+if __name__ == "__main__":
+    unittest.main()
+
+
+class CreateFields(unittest.TestCase):
+    """A misspelled create field is refused before anything is sent, naming the
+    one meant (user lane: memory_mb= reached the API as "memoryMb is not a
+    known field")."""
+
+    def test_a_misspelled_field_names_the_one_meant(self):
+        runtime = Runtime(api_key="rk", base_url="https://api.example.test")
+        runtime._t._http = None  # nothing may be sent
+        with self.assertRaises(TypeError) as caught:
+            runtime.sandboxes.create(memory_mb=8192)
+        self.assertIn("Did you mean 'memory_mib'?", str(caught.exception))
+
+    def test_snake_and_camel_names_both_pass(self):
+        from withruntime._sync_client import _check_create_fields
+        _check_create_fields({"memory_mib": 1, "memoryMiB": 1, "snapshot_id": "s", "get_or_create": True})

withruntime-0.7.0/tests/test_files_download.py

@@ -0,0 +1,137 @@
+"""A download that arrives short is never returned short (25 September 2026).
+
+`s.files.read` of a 50 MB file returned 44 MB and raised nothing: a stream the
+controller broke part way reached the client as a clean end of a chunked
+body. The API now sends every body's length first (x-content-length) and a
+small one's SHA-256; the SDK reads a short body again, then raises
+``download_incomplete``. A real HTTP server here, so the chunked parsing in
+``_http.py`` is what is tested, not a stand-in."""
+import asyncio
+import hashlib
+import json
+import os
+import tempfile
+import threading
+import unittest
+from http.server import BaseHTTPRequestHandler, ThreadingHTTPServer
+
+from withruntime import AsyncRuntime, Runtime
+from withruntime._errors import RuntimeError
+
+ID = "8a1f9c2e-0d1b-4c3a-9e8f-7a6b5c4d3e2f"
+WHOLE = bytes((i * 31) & 0xFF for i in range(3 * 1_048_576 + 7))
+
+
+class World:
+    def __init__(self, cuts, sha=None):
+        self.cuts, self.sha, self.reads = list(cuts), sha, 0
+        world = self
+
+        class Handler(BaseHTTPRequestHandler):
+            protocol_version = "HTTP/1.1"
+
+            def log_message(self, *args):
+                pass
+
+            def do_GET(self):
+                if "/files/stat" in self.path:
+                    return self.json({"exists": True, "type": "file", "path": "/workspace/big.bin"})
+                if "/files/content" in self.path:
+                    cut = world.cuts[world.reads] if world.reads < len(world.cuts) else None
+                    world.reads += 1
+                    body = WHOLE if cut is None else WHOLE[:cut]
+                    self.send_response(200)
+                    self.send_header("content-type", "application/octet-stream")
+                    self.send_header("transfer-encoding", "chunked")
+                    self.send_header("x-content-length", str(len(WHOLE)))
+                    if world.sha:
+                        self.send_header("x-content-sha256", world.sha)
+                    self.end_headers()
+                    for at in range(0, len(body), 65536):
+                        piece = body[at:at + 65536]
+                        self.wfile.write(b"%x\r\n" % len(piece) + piece + b"\r\n")
+                    # A clean end even when short: what Caddy 2.6 sends.
+                    self.wfile.write(b"0\r\n\r\n")
+                    return
+                return self.json({"id": ID, "kind": "sandbox", "state": "running", "status": "active"})
+
+            def json(self, value):
+                data = json.dumps(value).encode()
+                self.send_response(200)
+                self.send_header("content-type", "application/json")
+                self.send_header("content-length", str(len(data)))
+                self.end_headers()
+                self.wfile.write(data)
+
+        self.server = ThreadingHTTPServer(("127.0.0.1", 0), Handler)
+        threading.Thread(target=self.server.serve_forever, daemon=True).start()
+        self.url = f"http://localhost:{self.server.server_address[1]}"
+
+    def close(self):
+        self.server.shutdown()
+        self.server.server_close()
+
+
+class Downloads(unittest.TestCase):
+    def world(self, cuts, sha=None):
+        world = World(cuts, sha)
+        self.addCleanup(world.close)
+        return world, Runtime(api_key="rt_test", base_url=world.url, max_retries=0)
+
+    def test_short_read_is_read_again(self):
+        world, runtime = self.world([2_966_523, 1_441_474])
+        self.assertEqual(runtime.sandboxes.get(ID).files.read("/workspace/big.bin"), WHOLE)
+        self.assertEqual(world.reads, 3)
+
+    def test_read_that_stays_short_raises(self):
+        world, runtime = self.world([10, 20, 30, 40])
+        with self.assertRaises(RuntimeError) as caught:
+            runtime.sandboxes.get(ID).files.read("/workspace/big.bin")
+        self.assertEqual(caught.exception.code, "download_incomplete")
+        self.assertEqual(caught.exception.details, {"received": 30, "expected": len(WHOLE)})
+        self.assertEqual(world.reads, 3)
+
+    def test_digest_mismatch_raises(self):
+        _, runtime = self.world([], sha="0" * 64)
+        with self.assertRaises(RuntimeError):
+            runtime.sandboxes.get(ID).files.read("/workspace/big.bin")
+        _, runtime = self.world([], sha=hashlib.sha256(WHOLE).hexdigest())
+        self.assertEqual(runtime.sandboxes.get(ID).files.read("/workspace/big.bin"), WHOLE)
+
+    def test_read_stream_raises_when_short(self):
+        _, runtime = self.world([2_000_000])
+        files = runtime.sandboxes.get(ID).files
+        with self.assertRaises(RuntimeError) as caught:
+            b"".join(files.read_stream("/workspace/big.bin"))
+        self.assertEqual(caught.exception.code, "download_incomplete")
+        self.assertEqual(b"".join(files.read_stream("/workspace/big.bin")), WHOLE)
+
+    def test_download_never_leaves_a_short_file(self):
+        with tempfile.TemporaryDirectory() as directory:
+            _, runtime = self.world([1_000_000])
+            target = os.path.join(directory, "o.bin")
+            runtime.sandboxes.get(ID).files.download("/workspace/big.bin", target)
+            with open(target, "rb") as handle:
+                self.assertEqual(handle.read(), WHOLE)
+            _, runtime = self.world([1, 2, 3, 4])
+            with self.assertRaises(RuntimeError):
+                runtime.sandboxes.get(ID).files.download("/workspace/big.bin", os.path.join(directory, "lost.bin"))
+            self.assertEqual(os.listdir(directory), ["o.bin"])
+
+    def test_async_read_and_stream(self):
+        world = World([5, 6])
+        self.addCleanup(world.close)
+
+        async def run():
+            async with AsyncRuntime(api_key="rt_test", base_url=world.url, max_retries=0) as runtime:
+                files = (await runtime.sandboxes.get(ID)).files
+                self.assertEqual(await files.read("/workspace/big.bin"), WHOLE)
+                world.cuts, world.reads = [7], 0
+                with self.assertRaises(RuntimeError):
+                    async for _ in files.read_stream("/workspace/big.bin"):
+                        pass
+        asyncio.run(run())
+
+
+if __name__ == "__main__":
+    unittest.main()

{withruntime-0.6.1 → withruntime-0.7.0}/tests/test_harbor.py

@@ -145,9 +145,9 @@ class FakeSandbox:
             yield {"type": "stdout", "offset": 0, "data": out.decode("utf-8", "replace")}
         if err:
             yield {"type": "stderr", "offset": 0, "data": err.decode("utf-8", "replace")}
-        code = proc.returncode
-        yield {"type": "exit", "exitCode": None if timed_out else (128 - code if code < 0 else code),
-               "timedOut": timed_out}
+        # As the live API reports it: a command past its limit is killed and reads -9,
+        # and a command a signal ended reads the negative signal number (-15, -9).
+        yield {"type": "exit", "exitCode": -9 if timed_out else proc.returncode, "timedOut": timed_out}
 
     def keep_alive(self, every_seconds=60, margin_seconds=600):
         self.alive = True

withruntime-0.7.0/tests/test_late_answer.py

@@ -0,0 +1,69 @@
+"""An answer later than the API holds its headers arrives as a 200 with
+runtime-late-answer: true, then the answer or {"error": ...}. A failure is
+raised as its typed error (packages/cloud/src/api/hold.ts). Sync and async."""
+import asyncio
+import json
+import unittest
+
+from withruntime import AsyncRuntime, NotFoundError, Runtime
+
+ID = "8a1f9c2e-0d1b-4c3a-9e8f-7a6b5c4d3e2f"
+
+
+class Wire:
+    def __init__(self, body, is_async):
+        self.body, self.is_async = body, is_async
+
+    def send(self, method, target, headers, data, timeout):
+        body = self.body.encode()
+        is_async = self.is_async
+
+        class Answer:
+            status, headers = 200, {"runtime-late-answer": "true"}
+            if is_async:
+                async def read(self):
+                    return body
+            else:
+                def read(self):
+                    return body
+        if is_async:
+            async def later():
+                return Answer()
+            return later()
+        return Answer()
+
+
+def call(body):
+    outcomes = []
+    for is_async in (False, True):
+        runtime = (AsyncRuntime if is_async else Runtime)(api_key="rk", base_url="https://api.example.test")
+        runtime._t._http = Wire(body, is_async)
+        try:
+            if is_async:
+                outcomes.append(asyncio.run(runtime._t.json("POST", f"/v1/sandboxes/{ID}:exec", body={})))
+            else:
+                outcomes.append(runtime._t.json("POST", f"/v1/sandboxes/{ID}:exec", body={}))
+        except Exception as error:  # noqa: BLE001 - the outcome under test
+            outcomes.append(error)
+    return outcomes
+
+
+class LateAnswer(unittest.TestCase):
+    def test_a_late_success_is_the_answer(self):
+        for outcome in call('\n\n{"exitCode": 0, "stdout": "done"}'):
+            self.assertEqual(outcome["stdout"], "done")
+
+    def test_a_late_failure_is_raised_typed(self):
+        body = json.dumps({"error": {"code": "sandbox_not_found", "status": 404, "message": "Gone.",
+                                     "requestId": "req_1"}})
+        for outcome in call("\n" + body):
+            self.assertIsInstance(outcome, NotFoundError)
+            self.assertEqual(outcome.request_id, "req_1")
+
+    def test_an_answer_with_its_own_error_field_stays_an_answer(self):
+        for outcome in call(json.dumps({"status": "error", "error": {"name": "ValueError"}})):
+            self.assertEqual(outcome["error"]["name"], "ValueError")
+
+
+if __name__ == "__main__":
+    unittest.main()