1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
import assert from "node:assert/strict";
import { test } from "node:test";
import { did, load } from "../../../rust/src/harness.mjs";
const { module, run, handle } = await load(new URL("../../../target/wasm32-unknown-unknown/release/echo.wasm", import.meta.url), new URL("./module.json", import.meta.url));
const service = "https://relay.example";
const SUB = "com.atproto.sync.subscribeRepos";
const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
const respond = (messages) => (call) => (call.subscribe ? messages : { ok: true, output: { handle: "alice.test", did } });
test("module has no imports and exports the ABI", () => {
assert.equal(WebAssembly.Module.imports(module).length, 0);
const names = WebAssembly.Module.exports(module).map((e) => e.name);
for (const name of ["memory", "alloc", "watch"]) assert.ok(names.includes(name), name);
});
test("start describes the repo, subscribes and sets a timer in one output", () => {
const out = run("watch", { did, now: "x", service, seconds: "2", state: null, event: { type: "start" } });
assert.deepEqual(out.calls, [
{ id: "who", nsid: "com.atproto.repo.describeRepo", params: { repo: did } },
{ id: "feed", nsid: SUB, service, subscribe: true },
]);
assert.deepEqual(out.timers, [{ id: "stop", ms: 2000 }]);
assert.deepEqual(out.state, { handle: null, count: 0, last: null });
});
// Paced (as rust/host/conformance.test.mjs): four instant messages would end the stream before the
// module's cancel lands, and which comes first would be a scheduler's choice, not the module's.
async function* paced(messages, ms = 20) {
for (const message of messages) {
await sleep(ms);
yield message;
}
}
test("counts messages to the limit, then cancels the stream and finishes", async () => {
const messages = [1, 2, 3, 4].map((seq) => ({ $type: `${SUB}#commit`, seq }));
const ran = await handle("watch", { service, limit: 3 }, { respond: respond(paced(messages)) });
assert.equal(ran.error, undefined);
assert.deepEqual(ran.result, { handle: "alice.test", count: 3, last: { $type: `${SUB}#commit`, seq: 3 }, stopped: "limit" });
assert.ok(ran.calls.some((c) => c.id === "feed" && c.cancelled));
});
test("a stream that closes early finishes with what it saw; a failed stream reports its error", async () => {
const closed = await handle("watch", { service, limit: "10" }, { respond: respond([{ seq: 1 }]) });
assert.equal(closed.result.stopped, "closed");
assert.equal(closed.result.count, 1);
async function* failing() {
yield { seq: 9 };
throw new Error("FutureCursor");
}
const failed = await handle("watch", { service }, { respond: (call) => (call.subscribe ? failing() : { ok: false, error: "RepoNotFound" }) });
assert.deepEqual(failed.result, { handle: null, count: 1, last: { $type: null, seq: 9 }, stopped: "FutureCursor" });
});
test("inputs are echoed up the stream; the timer ends a quiet run", async () => {
async function* quiet() {
await sleep(1200);
}
async function* inputs() {
yield { $type: "#ping", n: 1 };
}
const ran = await handle("watch", { service, seconds: 1 }, { respond: respond(quiet()), inputs: inputs() });
assert.deepEqual(ran.sends, [{ nsid: SUB, data: { $type: "#ping", n: 1 } }]);
assert.equal(ran.result.stopped, "time");
});
test("bad input is an error, as data", async () => {
assert.equal((await handle("watch", { service: "http://x" }, { respond: respond([]) })).error, "service must be an https origin");
assert.equal(run("watch", { did, now: "x", service, limit: "0", event: { type: "start" } }).error, "limit must be 1 to 1000");
assert.match(run("watch", { now: "x", service, event: { type: "start" } }).error, /invalid input/);
});
test("connect passes its input to one iroh.connect call and finishes with the output", async () => {
const input = { ticket: "endpointabc", hostKeys: [{ type: "ssh-ed25519", publicKey: "AAAA" }], command: "cat", stdin: "hi" };
const ran = await handle("connect", input, { respond: (call) => (call.nsid === "com.fedfork.exec.iroh.connect" && call.input.stdin === "hi" ? { ok: true, output: { output: "hi", exitCode: 0 } } : { ok: false, error: "unexpected" }) });
assert.deepEqual(ran.result, { output: "hi", exitCode: 0 });
});
