@dudousxd/nestjs-durable-testing 0.22.2 → 0.23.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/dist/index.d.ts +47 -1
- package/dist/index.js +704 -0
- package/dist/index.js.map +1 -1
- package/package.json +2 -2
package/dist/index.js
CHANGED
|
@@ -841,6 +841,7 @@ function runStateStoreContract(name, makeStore) {
|
|
|
841
841
|
let cleanup;
|
|
842
842
|
let supportsAsyncTransaction = true;
|
|
843
843
|
let supportsTagFilter = true;
|
|
844
|
+
let statements;
|
|
844
845
|
let skipReason;
|
|
845
846
|
let loggedSkip = false;
|
|
846
847
|
beforeEach(async () => {
|
|
@@ -851,6 +852,7 @@ function runStateStoreContract(name, makeStore) {
|
|
|
851
852
|
cleanup = ctx.cleanup;
|
|
852
853
|
supportsAsyncTransaction = ctx.supportsAsyncTransaction ?? true;
|
|
853
854
|
supportsTagFilter = ctx.supportsTagFilter ?? true;
|
|
855
|
+
statements = ctx.statements;
|
|
854
856
|
skipReason = void 0;
|
|
855
857
|
} catch (err) {
|
|
856
858
|
if (isUnavailable(err) && !process.env.DURABLE_TEST_REQUIRE_BACKENDS) {
|
|
@@ -1484,6 +1486,70 @@ function runStateStoreContract(name, makeStore) {
|
|
|
1484
1486
|
"chatty-old"
|
|
1485
1487
|
]);
|
|
1486
1488
|
});
|
|
1489
|
+
t("a parent joining children that already finished settles them from their rows", async () => {
|
|
1490
|
+
const engine = new WorkflowEngine3({
|
|
1491
|
+
store,
|
|
1492
|
+
reconcileMs: 0
|
|
1493
|
+
});
|
|
1494
|
+
engine.register("j-child", "1", async (_ctx, input) => ({
|
|
1495
|
+
n: input.n
|
|
1496
|
+
}));
|
|
1497
|
+
engine.register("j-parent", "1", async (ctx) => {
|
|
1498
|
+
const lone = await ctx.child("j-child", {
|
|
1499
|
+
n: 9
|
|
1500
|
+
}, "j-own-id");
|
|
1501
|
+
const fan = await ctx.allSettled("j-child", [
|
|
1502
|
+
{
|
|
1503
|
+
n: 0
|
|
1504
|
+
},
|
|
1505
|
+
{
|
|
1506
|
+
n: 1
|
|
1507
|
+
}
|
|
1508
|
+
]);
|
|
1509
|
+
return {
|
|
1510
|
+
lone,
|
|
1511
|
+
fan
|
|
1512
|
+
};
|
|
1513
|
+
});
|
|
1514
|
+
await engine.start("j-child", {
|
|
1515
|
+
n: 9
|
|
1516
|
+
}, "j-own-id");
|
|
1517
|
+
await engine.start("j-child", {
|
|
1518
|
+
n: 1
|
|
1519
|
+
}, "jp.all.1.1");
|
|
1520
|
+
expect3((await engine.waitForRun("j-own-id", {
|
|
1521
|
+
timeoutMs: 2e4
|
|
1522
|
+
})).status).toBe("completed");
|
|
1523
|
+
expect3((await engine.waitForRun("jp.all.1.1", {
|
|
1524
|
+
timeoutMs: 2e4
|
|
1525
|
+
})).status).toBe("completed");
|
|
1526
|
+
await engine.start("j-parent", {}, "jp");
|
|
1527
|
+
const deadline = Date.now() + 2e4;
|
|
1528
|
+
while ((await store.getRun("jp"))?.status !== "completed") {
|
|
1529
|
+
if (Date.now() > deadline) throw new Error("parent never completed");
|
|
1530
|
+
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
1531
|
+
}
|
|
1532
|
+
expect3((await store.getRun("jp"))?.output).toEqual({
|
|
1533
|
+
lone: {
|
|
1534
|
+
n: 9
|
|
1535
|
+
},
|
|
1536
|
+
fan: [
|
|
1537
|
+
{
|
|
1538
|
+
status: "fulfilled",
|
|
1539
|
+
value: {
|
|
1540
|
+
n: 0
|
|
1541
|
+
}
|
|
1542
|
+
},
|
|
1543
|
+
{
|
|
1544
|
+
status: "fulfilled",
|
|
1545
|
+
value: {
|
|
1546
|
+
n: 1
|
|
1547
|
+
}
|
|
1548
|
+
}
|
|
1549
|
+
]
|
|
1550
|
+
});
|
|
1551
|
+
await engine.drain(5e3);
|
|
1552
|
+
});
|
|
1487
1553
|
t("engine.purgeRuns deletes a scope with its child subtrees and cancels live runs", async () => {
|
|
1488
1554
|
const engine = new WorkflowEngine3({
|
|
1489
1555
|
store
|
|
@@ -2056,6 +2122,191 @@ function runStateStoreContract(name, makeStore) {
|
|
|
2056
2122
|
n: 3
|
|
2057
2123
|
});
|
|
2058
2124
|
});
|
|
2125
|
+
t("getCheckpoints reads many of a run's checkpoints at once, in seq order", async () => {
|
|
2126
|
+
expect3(store.getCheckpoints).toBeDefined();
|
|
2127
|
+
if (!store.getCheckpoints) return;
|
|
2128
|
+
await store.createRun(run());
|
|
2129
|
+
await store.createRun(run({
|
|
2130
|
+
id: "r2"
|
|
2131
|
+
}));
|
|
2132
|
+
expect3(await store.getCheckpoints("r1", [])).toEqual([]);
|
|
2133
|
+
for (const seq of [
|
|
2134
|
+
0,
|
|
2135
|
+
1,
|
|
2136
|
+
2,
|
|
2137
|
+
5
|
|
2138
|
+
]) {
|
|
2139
|
+
await store.saveCheckpoint(checkpoint({
|
|
2140
|
+
seq,
|
|
2141
|
+
stepId: `r1:${seq}`,
|
|
2142
|
+
output: {
|
|
2143
|
+
seq
|
|
2144
|
+
},
|
|
2145
|
+
wakeAt: seq === 2 ? 7e3 : void 0
|
|
2146
|
+
}));
|
|
2147
|
+
}
|
|
2148
|
+
await store.saveCheckpoint(checkpoint({
|
|
2149
|
+
runId: "r2",
|
|
2150
|
+
seq: 3,
|
|
2151
|
+
stepId: "r2:3"
|
|
2152
|
+
}));
|
|
2153
|
+
const read = await store.getCheckpoints("r1", [
|
|
2154
|
+
5,
|
|
2155
|
+
0,
|
|
2156
|
+
3,
|
|
2157
|
+
2,
|
|
2158
|
+
0
|
|
2159
|
+
]);
|
|
2160
|
+
expect3(read.map((c) => [
|
|
2161
|
+
c.runId,
|
|
2162
|
+
c.seq,
|
|
2163
|
+
c.output
|
|
2164
|
+
])).toEqual([
|
|
2165
|
+
[
|
|
2166
|
+
"r1",
|
|
2167
|
+
0,
|
|
2168
|
+
{
|
|
2169
|
+
seq: 0
|
|
2170
|
+
}
|
|
2171
|
+
],
|
|
2172
|
+
[
|
|
2173
|
+
"r1",
|
|
2174
|
+
2,
|
|
2175
|
+
{
|
|
2176
|
+
seq: 2
|
|
2177
|
+
}
|
|
2178
|
+
],
|
|
2179
|
+
[
|
|
2180
|
+
"r1",
|
|
2181
|
+
5,
|
|
2182
|
+
{
|
|
2183
|
+
seq: 5
|
|
2184
|
+
}
|
|
2185
|
+
]
|
|
2186
|
+
]);
|
|
2187
|
+
expect3(read[1]).toEqual(await store.getCheckpoint("r1", 2));
|
|
2188
|
+
const n = 1200;
|
|
2189
|
+
for (let seq = 10; seq < 10 + n; seq += 1) {
|
|
2190
|
+
await store.saveCheckpoint(checkpoint({
|
|
2191
|
+
seq,
|
|
2192
|
+
stepId: `r1:${seq}`
|
|
2193
|
+
}));
|
|
2194
|
+
}
|
|
2195
|
+
const wide = await store.getCheckpoints("r1", Array.from({
|
|
2196
|
+
length: n
|
|
2197
|
+
}, (_, i) => 10 + i));
|
|
2198
|
+
expect3(wide.map((c) => c.seq)).toEqual(Array.from({
|
|
2199
|
+
length: n
|
|
2200
|
+
}, (_, i) => 10 + i));
|
|
2201
|
+
});
|
|
2202
|
+
t("saveCheckpoints writes many checkpoints at once, inserting or overwriting each", async () => {
|
|
2203
|
+
expect3(store.saveCheckpoints).toBeDefined();
|
|
2204
|
+
if (!store.saveCheckpoints) return;
|
|
2205
|
+
await store.saveCheckpoints([]);
|
|
2206
|
+
await store.createRun(run());
|
|
2207
|
+
await store.saveCheckpoint(checkpoint({
|
|
2208
|
+
seq: 1,
|
|
2209
|
+
stepId: "r1:1",
|
|
2210
|
+
output: {
|
|
2211
|
+
old: true
|
|
2212
|
+
}
|
|
2213
|
+
}));
|
|
2214
|
+
await store.saveCheckpoints([
|
|
2215
|
+
checkpoint({
|
|
2216
|
+
seq: 0,
|
|
2217
|
+
stepId: "r1:0",
|
|
2218
|
+
status: "pending",
|
|
2219
|
+
output: void 0,
|
|
2220
|
+
wakeAt: 4e3
|
|
2221
|
+
}),
|
|
2222
|
+
checkpoint({
|
|
2223
|
+
seq: 1,
|
|
2224
|
+
stepId: "r1:1",
|
|
2225
|
+
output: {
|
|
2226
|
+
new: true
|
|
2227
|
+
},
|
|
2228
|
+
parallelGroup: "g"
|
|
2229
|
+
}),
|
|
2230
|
+
checkpoint({
|
|
2231
|
+
seq: 2,
|
|
2232
|
+
stepId: "r1:2",
|
|
2233
|
+
input: {
|
|
2234
|
+
i: 2
|
|
2235
|
+
},
|
|
2236
|
+
workerGroup: "w"
|
|
2237
|
+
})
|
|
2238
|
+
]);
|
|
2239
|
+
const rows = await store.listCheckpoints("r1");
|
|
2240
|
+
expect3(rows.map((c) => [
|
|
2241
|
+
c.seq,
|
|
2242
|
+
c.status,
|
|
2243
|
+
c.output
|
|
2244
|
+
])).toEqual([
|
|
2245
|
+
[
|
|
2246
|
+
0,
|
|
2247
|
+
"pending",
|
|
2248
|
+
void 0
|
|
2249
|
+
],
|
|
2250
|
+
[
|
|
2251
|
+
1,
|
|
2252
|
+
"completed",
|
|
2253
|
+
{
|
|
2254
|
+
new: true
|
|
2255
|
+
}
|
|
2256
|
+
],
|
|
2257
|
+
[
|
|
2258
|
+
2,
|
|
2259
|
+
"completed",
|
|
2260
|
+
{
|
|
2261
|
+
ok: true
|
|
2262
|
+
}
|
|
2263
|
+
]
|
|
2264
|
+
]);
|
|
2265
|
+
expect3(rows[0]?.wakeAt).toBe(4e3);
|
|
2266
|
+
expect3(rows[1]?.parallelGroup).toBe("g");
|
|
2267
|
+
expect3(rows[2]?.input).toEqual({
|
|
2268
|
+
i: 2
|
|
2269
|
+
});
|
|
2270
|
+
expect3(rows[2]?.workerGroup).toBe("w");
|
|
2271
|
+
});
|
|
2272
|
+
t("the batched checkpoint methods send a fixed number of statements for a wide batch", async () => {
|
|
2273
|
+
if (!statements || !store.saveCheckpoints || !store.saveCheckpointsIfPending) return;
|
|
2274
|
+
if (!store.getCheckpoints) return;
|
|
2275
|
+
await store.createRun(run());
|
|
2276
|
+
const n = 600;
|
|
2277
|
+
const limit = n / 20;
|
|
2278
|
+
const rows = Array.from({
|
|
2279
|
+
length: n
|
|
2280
|
+
}, (_, seq) => checkpoint({
|
|
2281
|
+
seq,
|
|
2282
|
+
stepId: `r1:${seq}`,
|
|
2283
|
+
status: "pending",
|
|
2284
|
+
output: void 0
|
|
2285
|
+
}));
|
|
2286
|
+
const sent = /* @__PURE__ */ __name(async (work) => {
|
|
2287
|
+
const before = statements();
|
|
2288
|
+
await work();
|
|
2289
|
+
return statements() - before;
|
|
2290
|
+
}, "sent");
|
|
2291
|
+
expect3(await sent(() => store.saveCheckpoints?.(rows))).toBeLessThanOrEqual(limit);
|
|
2292
|
+
const seqs = rows.map((r) => r.seq);
|
|
2293
|
+
expect3(await sent(() => store.getCheckpoints?.("r1", seqs))).toBeLessThanOrEqual(limit);
|
|
2294
|
+
const settled = rows.map((row) => ({
|
|
2295
|
+
...row,
|
|
2296
|
+
status: "completed",
|
|
2297
|
+
output: {
|
|
2298
|
+
seq: row.seq
|
|
2299
|
+
}
|
|
2300
|
+
}));
|
|
2301
|
+
let wrote = [];
|
|
2302
|
+
expect3(await sent(async () => {
|
|
2303
|
+
wrote = await store.saveCheckpointsIfPending?.(settled) ?? [];
|
|
2304
|
+
})).toBeLessThanOrEqual(limit);
|
|
2305
|
+
expect3(wrote.every((w) => w)).toBe(true);
|
|
2306
|
+
expect3(await store.countCheckpoints?.("r1", 0, n - 1, [
|
|
2307
|
+
"completed"
|
|
2308
|
+
])).toBe(n);
|
|
2309
|
+
});
|
|
2059
2310
|
t("saveCheckpointsIfPending writes a wide batch", async () => {
|
|
2060
2311
|
if (!store.saveCheckpointsIfPending) return;
|
|
2061
2312
|
await store.createRun(run());
|
|
@@ -3963,6 +4214,111 @@ function runStateStoreContract(name, makeStore) {
|
|
|
3963
4214
|
seq: 0
|
|
3964
4215
|
});
|
|
3965
4216
|
});
|
|
4217
|
+
t("lists buffered signals by token prefix in insertion order, a page at a time", async () => {
|
|
4218
|
+
expect3(store.listBufferedSignals).toBeTypeOf("function");
|
|
4219
|
+
const list = /* @__PURE__ */ __name((prefix, after, limit) => store.listBufferedSignals?.(prefix, after, limit) ?? Promise.resolve([]), "list");
|
|
4220
|
+
await store.bufferSignal("child:a", {
|
|
4221
|
+
ok: true,
|
|
4222
|
+
value: {
|
|
4223
|
+
n: 1
|
|
4224
|
+
}
|
|
4225
|
+
});
|
|
4226
|
+
await store.bufferSignal("order:1", {
|
|
4227
|
+
paid: true
|
|
4228
|
+
});
|
|
4229
|
+
await store.bufferSignal("child:b", {
|
|
4230
|
+
ok: false,
|
|
4231
|
+
error: "x"
|
|
4232
|
+
});
|
|
4233
|
+
await store.bufferSignal("child:a", {
|
|
4234
|
+
ok: true,
|
|
4235
|
+
value: {
|
|
4236
|
+
n: 2
|
|
4237
|
+
}
|
|
4238
|
+
});
|
|
4239
|
+
await store.bufferSignal("wake_x:1", null);
|
|
4240
|
+
await store.bufferSignal("wakeyx:1", null);
|
|
4241
|
+
const all = await list("child:", void 0, 10);
|
|
4242
|
+
expect3(all.map((r) => [
|
|
4243
|
+
r.token,
|
|
4244
|
+
r.payload
|
|
4245
|
+
])).toEqual([
|
|
4246
|
+
[
|
|
4247
|
+
"child:a",
|
|
4248
|
+
{
|
|
4249
|
+
ok: true,
|
|
4250
|
+
value: {
|
|
4251
|
+
n: 1
|
|
4252
|
+
}
|
|
4253
|
+
}
|
|
4254
|
+
],
|
|
4255
|
+
[
|
|
4256
|
+
"child:b",
|
|
4257
|
+
{
|
|
4258
|
+
ok: false,
|
|
4259
|
+
error: "x"
|
|
4260
|
+
}
|
|
4261
|
+
],
|
|
4262
|
+
[
|
|
4263
|
+
"child:a",
|
|
4264
|
+
{
|
|
4265
|
+
ok: true,
|
|
4266
|
+
value: {
|
|
4267
|
+
n: 2
|
|
4268
|
+
}
|
|
4269
|
+
}
|
|
4270
|
+
]
|
|
4271
|
+
]);
|
|
4272
|
+
expect3(all.map((r) => typeof r.id)).toEqual([
|
|
4273
|
+
"string",
|
|
4274
|
+
"string",
|
|
4275
|
+
"string"
|
|
4276
|
+
]);
|
|
4277
|
+
const first = await list("child:", void 0, 2);
|
|
4278
|
+
expect3(first.map((r) => r.id)).toEqual(all.slice(0, 2).map((r) => r.id));
|
|
4279
|
+
const rest = await list("child:", first.at(-1)?.id, 2);
|
|
4280
|
+
expect3(rest.map((r) => r.id)).toEqual([
|
|
4281
|
+
all[2]?.id
|
|
4282
|
+
]);
|
|
4283
|
+
expect3(await list("child:", all[2]?.id, 2)).toEqual([]);
|
|
4284
|
+
expect3((await list("wake_x:", void 0, 10)).map((r) => r.token)).toEqual([
|
|
4285
|
+
"wake_x:1"
|
|
4286
|
+
]);
|
|
4287
|
+
});
|
|
4288
|
+
t("deletes buffered signals by id and leaves the rest in FIFO order", async () => {
|
|
4289
|
+
expect3(store.deleteBufferedSignals).toBeTypeOf("function");
|
|
4290
|
+
await store.bufferSignal("child:a", {
|
|
4291
|
+
n: 1
|
|
4292
|
+
});
|
|
4293
|
+
await store.bufferSignal("child:a", {
|
|
4294
|
+
n: 2
|
|
4295
|
+
});
|
|
4296
|
+
await store.bufferSignal("child:a", {
|
|
4297
|
+
n: 3
|
|
4298
|
+
});
|
|
4299
|
+
await store.bufferSignal("child:b", {
|
|
4300
|
+
n: 4
|
|
4301
|
+
});
|
|
4302
|
+
const rows = await store.listBufferedSignals?.("child:", void 0, 10) ?? [];
|
|
4303
|
+
await store.deleteBufferedSignals?.([
|
|
4304
|
+
rows[1]?.id,
|
|
4305
|
+
rows[3]?.id,
|
|
4306
|
+
"999999999"
|
|
4307
|
+
]);
|
|
4308
|
+
await store.deleteBufferedSignals?.([]);
|
|
4309
|
+
expect3(await store.takeBufferedSignal("child:a")).toEqual({
|
|
4310
|
+
payload: {
|
|
4311
|
+
n: 1
|
|
4312
|
+
}
|
|
4313
|
+
});
|
|
4314
|
+
expect3(await store.takeBufferedSignal("child:a")).toEqual({
|
|
4315
|
+
payload: {
|
|
4316
|
+
n: 3
|
|
4317
|
+
}
|
|
4318
|
+
});
|
|
4319
|
+
expect3(await store.takeBufferedSignal("child:a")).toBeNull();
|
|
4320
|
+
expect3(await store.takeBufferedSignal("child:b")).toBeNull();
|
|
4321
|
+
});
|
|
3966
4322
|
t("buffers signals and takes them FIFO per token", async () => {
|
|
3967
4323
|
await store.bufferSignal("sig", {
|
|
3968
4324
|
n: 1
|
|
@@ -4526,6 +4882,26 @@ var MID_TURN = [
|
|
|
4526
4882
|
signal: true
|
|
4527
4883
|
}
|
|
4528
4884
|
];
|
|
4885
|
+
var HOLDER_DIES = [
|
|
4886
|
+
{
|
|
4887
|
+
when: "after deciding to run the turn a kept wake asks for, before running it",
|
|
4888
|
+
// The lease of that turn, or its dispatch on the run queue.
|
|
4889
|
+
storeTrigger: [
|
|
4890
|
+
"tryLockRun"
|
|
4891
|
+
],
|
|
4892
|
+
transportTrigger: [
|
|
4893
|
+
"dispatchRuns"
|
|
4894
|
+
]
|
|
4895
|
+
},
|
|
4896
|
+
{
|
|
4897
|
+
when: "right after writing its suspension, before looking at the kept wake",
|
|
4898
|
+
// Releasing the lease, which comes before the look.
|
|
4899
|
+
storeTrigger: [
|
|
4900
|
+
"releaseRunLock"
|
|
4901
|
+
],
|
|
4902
|
+
transportTrigger: []
|
|
4903
|
+
}
|
|
4904
|
+
];
|
|
4529
4905
|
async function shutdown(all, transports) {
|
|
4530
4906
|
await Promise.allSettled(all.map(({ engine }) => engine.drain(2e3)));
|
|
4531
4907
|
await Promise.allSettled(transports.map((t) => t.close?.()));
|
|
@@ -5092,6 +5468,59 @@ function runRunDispatchContract(name, makeHarness, options = {}) {
|
|
|
5092
5468
|
await Promise.allSettled(pair.map((t) => t.close?.()));
|
|
5093
5469
|
}
|
|
5094
5470
|
}, timeoutMs + 1e4);
|
|
5471
|
+
for (const { fan, settle: settle2 } of FANS) {
|
|
5472
|
+
it3(`a ${fan} joined after some of its children finished settles them at once (reconcile off)`, async (ctx) => {
|
|
5473
|
+
const pair = await pairOrSkip(() => ctx.skip());
|
|
5474
|
+
if (!pair) return;
|
|
5475
|
+
const store = new InMemoryStateStore4();
|
|
5476
|
+
const all = instances(store, pair);
|
|
5477
|
+
for (const { engine } of all) {
|
|
5478
|
+
engine.register("line", "1", async (_ctx, input) => input.i * 10);
|
|
5479
|
+
engine.register("parent", "1", async (c) => {
|
|
5480
|
+
const inputs = [
|
|
5481
|
+
0,
|
|
5482
|
+
1,
|
|
5483
|
+
2,
|
|
5484
|
+
3
|
|
5485
|
+
].map((i) => ({
|
|
5486
|
+
i
|
|
5487
|
+
}));
|
|
5488
|
+
return settle2 ? c.allSettled("line", inputs) : c.all("line", inputs);
|
|
5489
|
+
});
|
|
5490
|
+
}
|
|
5491
|
+
try {
|
|
5492
|
+
for (const { engine } of all) engine.consumeRuns();
|
|
5493
|
+
const [first] = all;
|
|
5494
|
+
for (const i of [
|
|
5495
|
+
1,
|
|
5496
|
+
3
|
|
5497
|
+
]) await first.engine.start("line", {
|
|
5498
|
+
i
|
|
5499
|
+
}, `p.all.0.${i}`);
|
|
5500
|
+
await until(async () => {
|
|
5501
|
+
const runs = await Promise.all([
|
|
5502
|
+
1,
|
|
5503
|
+
3
|
|
5504
|
+
].map((i) => store.getRun(`p.all.0.${i}`)));
|
|
5505
|
+
return runs.every((r) => r?.status === "completed");
|
|
5506
|
+
}, timeoutMs);
|
|
5507
|
+
await first.engine.start("parent", {}, "p");
|
|
5508
|
+
await until(async () => (await store.getRun("p"))?.status === "completed", timeoutMs);
|
|
5509
|
+
const values = [
|
|
5510
|
+
0,
|
|
5511
|
+
10,
|
|
5512
|
+
20,
|
|
5513
|
+
30
|
|
5514
|
+
];
|
|
5515
|
+
expect4((await store.getRun("p"))?.output).toEqual(settle2 ? values.map((value) => ({
|
|
5516
|
+
status: "fulfilled",
|
|
5517
|
+
value
|
|
5518
|
+
})) : values);
|
|
5519
|
+
} finally {
|
|
5520
|
+
await shutdown(all, pair);
|
|
5521
|
+
}
|
|
5522
|
+
}, timeoutMs + 1e4);
|
|
5523
|
+
}
|
|
5095
5524
|
it3("drain waits for a run taken off the queue, and the draining instance takes no more", async (ctx) => {
|
|
5096
5525
|
const pair = await pairOrSkip(() => ctx.skip());
|
|
5097
5526
|
if (!pair) return;
|
|
@@ -5198,13 +5627,287 @@ function runRunDispatchContract(name, makeHarness, options = {}) {
|
|
|
5198
5627
|
}
|
|
5199
5628
|
}, timeoutMs + 2e4);
|
|
5200
5629
|
}
|
|
5630
|
+
for (const { when, storeTrigger, transportTrigger } of HOLDER_DIES) {
|
|
5631
|
+
it3(`a wake kept for a turn survives the instance holding the run going down ${when}`, async (ctx) => {
|
|
5632
|
+
const pair = await pairOrSkip(() => ctx.skip());
|
|
5633
|
+
if (!pair) return;
|
|
5634
|
+
const inner = new InMemoryStateStore4();
|
|
5635
|
+
let now = Date.now();
|
|
5636
|
+
const clock = /* @__PURE__ */ __name(() => now, "clock");
|
|
5637
|
+
let armed = false;
|
|
5638
|
+
let dead = false;
|
|
5639
|
+
const hang = /* @__PURE__ */ __name(() => new Promise(() => {
|
|
5640
|
+
}), "hang");
|
|
5641
|
+
const cutOff = /* @__PURE__ */ __name((target, trigger) => new Proxy(target, {
|
|
5642
|
+
get(t, prop, receiver) {
|
|
5643
|
+
const value = Reflect.get(t, prop, receiver);
|
|
5644
|
+
if (typeof value !== "function") return value;
|
|
5645
|
+
return (...args) => {
|
|
5646
|
+
if (armed && trigger.includes(String(prop))) dead = true;
|
|
5647
|
+
return dead ? hang() : value.apply(t, args);
|
|
5648
|
+
};
|
|
5649
|
+
}
|
|
5650
|
+
}), "cutOff");
|
|
5651
|
+
const holderStore = cutOff(inner, storeTrigger);
|
|
5652
|
+
const holderTransport = cutOff(pair[0], transportTrigger);
|
|
5653
|
+
let requesterDead = false;
|
|
5654
|
+
const requesterStore = new Proxy(inner, {
|
|
5655
|
+
get(t, prop, receiver) {
|
|
5656
|
+
const value = Reflect.get(t, prop, receiver);
|
|
5657
|
+
if (typeof value !== "function") return value;
|
|
5658
|
+
return (...args) => requesterDead ? hang() : value.apply(t, args);
|
|
5659
|
+
}
|
|
5660
|
+
});
|
|
5661
|
+
let turns = 0;
|
|
5662
|
+
let openTurn;
|
|
5663
|
+
const held = new Promise((resolve) => {
|
|
5664
|
+
openTurn = resolve;
|
|
5665
|
+
});
|
|
5666
|
+
const make = /* @__PURE__ */ __name((store, transport) => {
|
|
5667
|
+
const engine = new WorkflowEngine5({
|
|
5668
|
+
store,
|
|
5669
|
+
transport,
|
|
5670
|
+
clock,
|
|
5671
|
+
reconcileMs: 3e5
|
|
5672
|
+
});
|
|
5673
|
+
engine.register("kept", "1", async (wctx) => {
|
|
5674
|
+
turns += 1;
|
|
5675
|
+
if (turns === 2) await held;
|
|
5676
|
+
await wctx.waitForSignal("go");
|
|
5677
|
+
});
|
|
5678
|
+
return engine;
|
|
5679
|
+
}, "make");
|
|
5680
|
+
const holder = make(holderStore, holderTransport);
|
|
5681
|
+
const requester = make(requesterStore, pair[1]);
|
|
5682
|
+
let survivor;
|
|
5683
|
+
try {
|
|
5684
|
+
holder.consumeRuns();
|
|
5685
|
+
await holder.start("kept", {}, "p");
|
|
5686
|
+
await until(async () => (await inner.getRun("p"))?.status === "suspended", timeoutMs);
|
|
5687
|
+
void holder.resume("p").catch(() => void 0);
|
|
5688
|
+
await until(() => turns === 2, timeoutMs);
|
|
5689
|
+
await requester.resume("p");
|
|
5690
|
+
await until(async () => {
|
|
5691
|
+
const run2 = await inner.getRun("p");
|
|
5692
|
+
return run2?.wakeAt !== void 0 && run2.wakeAt <= now + 31e3;
|
|
5693
|
+
}, timeoutMs);
|
|
5694
|
+
await pause(100);
|
|
5695
|
+
requesterDead = true;
|
|
5696
|
+
armed = true;
|
|
5697
|
+
openTurn();
|
|
5698
|
+
await until(() => dead, timeoutMs);
|
|
5699
|
+
expect4(turns).toBe(2);
|
|
5700
|
+
await Promise.race([
|
|
5701
|
+
pair[0].close?.(),
|
|
5702
|
+
pause(2e3)
|
|
5703
|
+
]);
|
|
5704
|
+
await pause(1500);
|
|
5705
|
+
survivor = make(inner, pair[1]);
|
|
5706
|
+
survivor.consumeRuns();
|
|
5707
|
+
now += 31e3;
|
|
5708
|
+
await survivor.resumeDueTimers(now);
|
|
5709
|
+
await until(() => turns === 3, timeoutMs);
|
|
5710
|
+
expect4((await inner.getRun("p"))?.status).toBe("suspended");
|
|
5711
|
+
} finally {
|
|
5712
|
+
openTurn();
|
|
5713
|
+
requesterDead = true;
|
|
5714
|
+
await Promise.allSettled([
|
|
5715
|
+
survivor?.drain(2e3)
|
|
5716
|
+
]);
|
|
5717
|
+
await Promise.race([
|
|
5718
|
+
Promise.allSettled(pair.map((t) => t.close?.())),
|
|
5719
|
+
pause(5e3)
|
|
5720
|
+
]);
|
|
5721
|
+
}
|
|
5722
|
+
}, timeoutMs + 2e4);
|
|
5723
|
+
}
|
|
5201
5724
|
});
|
|
5202
5725
|
}
|
|
5203
5726
|
__name(runRunDispatchContract, "runRunDispatchContract");
|
|
5727
|
+
|
|
5728
|
+
// src/step-fan-results-contract.ts
|
|
5729
|
+
import { DURABLE_STEP_NAME, InMemoryStateStore as InMemoryStateStore5, WorkflowEngine as WorkflowEngine6 } from "@dudousxd/nestjs-durable-core";
|
|
5730
|
+
import { describe as describe4, expect as expect5, it as it4 } from "vitest";
|
|
5731
|
+
var STEP_FAN_STEP = "fan-results-double";
|
|
5732
|
+
var doubleLine = /* @__PURE__ */ __name(() => {
|
|
5733
|
+
}, "doubleLine");
|
|
5734
|
+
doubleLine[DURABLE_STEP_NAME] = STEP_FAN_STEP;
|
|
5735
|
+
function counted(inner, counts) {
|
|
5736
|
+
return new Proxy(inner, {
|
|
5737
|
+
get(target, prop, receiver) {
|
|
5738
|
+
const value = Reflect.get(target, prop, receiver);
|
|
5739
|
+
if (typeof value !== "function") return value;
|
|
5740
|
+
return (...args) => {
|
|
5741
|
+
const name = String(prop);
|
|
5742
|
+
counts.calls.set(name, (counts.calls.get(name) ?? 0) + 1);
|
|
5743
|
+
if (name === "saveCheckpointsIfPending") counts.batches.push(args[0].length);
|
|
5744
|
+
if (name === "saveCheckpointIfPending") counts.batches.push(1);
|
|
5745
|
+
return new Promise((resolve) => setImmediate(resolve)).then(() => value.apply(target, args));
|
|
5746
|
+
};
|
|
5747
|
+
}
|
|
5748
|
+
});
|
|
5749
|
+
}
|
|
5750
|
+
__name(counted, "counted");
|
|
5751
|
+
function behind(transport, gate, dispatched) {
|
|
5752
|
+
return new Proxy(transport, {
|
|
5753
|
+
get(target, prop, receiver) {
|
|
5754
|
+
if (prop === "dispatch") {
|
|
5755
|
+
return (...args) => {
|
|
5756
|
+
dispatched.one += 1;
|
|
5757
|
+
return target.dispatch(...args);
|
|
5758
|
+
};
|
|
5759
|
+
}
|
|
5760
|
+
if (prop === "onResult") {
|
|
5761
|
+
return (handler) => target.onResult(async (result) => {
|
|
5762
|
+
await gate;
|
|
5763
|
+
return handler(result);
|
|
5764
|
+
});
|
|
5765
|
+
}
|
|
5766
|
+
const value = Reflect.get(target, prop, receiver);
|
|
5767
|
+
return typeof value === "function" ? value.bind(target) : value;
|
|
5768
|
+
}
|
|
5769
|
+
});
|
|
5770
|
+
}
|
|
5771
|
+
__name(behind, "behind");
|
|
5772
|
+
async function until2(check, timeoutMs) {
|
|
5773
|
+
const deadline = Date.now() + timeoutMs;
|
|
5774
|
+
while (Date.now() < deadline) {
|
|
5775
|
+
if (await check()) return;
|
|
5776
|
+
await new Promise((resolve) => setTimeout(resolve, 20));
|
|
5777
|
+
}
|
|
5778
|
+
throw new Error("condition not met");
|
|
5779
|
+
}
|
|
5780
|
+
__name(until2, "until");
|
|
5781
|
+
var FORMS = [
|
|
5782
|
+
{
|
|
5783
|
+
form: "ctx.all",
|
|
5784
|
+
settle: false,
|
|
5785
|
+
waves: 1
|
|
5786
|
+
},
|
|
5787
|
+
{
|
|
5788
|
+
form: "ctx.allSettled",
|
|
5789
|
+
settle: true,
|
|
5790
|
+
waves: 1
|
|
5791
|
+
},
|
|
5792
|
+
{
|
|
5793
|
+
form: "ctx.all with concurrency",
|
|
5794
|
+
settle: false,
|
|
5795
|
+
waves: 4
|
|
5796
|
+
},
|
|
5797
|
+
{
|
|
5798
|
+
form: "ctx.allSettled with concurrency",
|
|
5799
|
+
settle: true,
|
|
5800
|
+
waves: 4
|
|
5801
|
+
}
|
|
5802
|
+
];
|
|
5803
|
+
function runStepFanResultsContract(name, makeHarness, options = {}) {
|
|
5804
|
+
const timeoutMs = options.timeoutMs ?? 6e4;
|
|
5805
|
+
const fanSize = options.fanSize ?? 2e3;
|
|
5806
|
+
const minBatch = options.minBatch ?? 8;
|
|
5807
|
+
const bulkDispatch = options.bulkDispatch ?? true;
|
|
5808
|
+
describe4(`Step fan results contract: ${name}`, () => {
|
|
5809
|
+
for (const { form, settle: settle2, waves } of FORMS) {
|
|
5810
|
+
const size = waves === 1 ? fanSize : Math.floor(fanSize / 2);
|
|
5811
|
+
const concurrency = waves === 1 ? void 0 : Math.ceil(size / waves);
|
|
5812
|
+
it4(`settles a ${form} fan of ${size} steps over two instances in batches`, async (ctx) => {
|
|
5813
|
+
const harness = await makeHarness();
|
|
5814
|
+
if (typeof harness === "string") {
|
|
5815
|
+
console.warn(`[step-fan-results contract] ${name} skipped: ${harness}`);
|
|
5816
|
+
ctx.skip();
|
|
5817
|
+
return;
|
|
5818
|
+
}
|
|
5819
|
+
const failing = settle2 ? /* @__PURE__ */ new Set([
|
|
5820
|
+
1,
|
|
5821
|
+
size - 2
|
|
5822
|
+
]) : /* @__PURE__ */ new Set();
|
|
5823
|
+
let ran = 0;
|
|
5824
|
+
let openBacklog;
|
|
5825
|
+
const backlog = new Promise((resolve) => {
|
|
5826
|
+
openBacklog = resolve;
|
|
5827
|
+
});
|
|
5828
|
+
const { engines: opened, close } = await harness.open(async (input) => {
|
|
5829
|
+
ran += 1;
|
|
5830
|
+
if (ran >= (concurrency ?? size)) openBacklog();
|
|
5831
|
+
const { i } = input;
|
|
5832
|
+
if (failing.has(i)) throw Object.assign(new Error(`bad ${i}`), {
|
|
5833
|
+
retryable: false
|
|
5834
|
+
});
|
|
5835
|
+
return i * 2;
|
|
5836
|
+
});
|
|
5837
|
+
const dispatched = {
|
|
5838
|
+
one: 0
|
|
5839
|
+
};
|
|
5840
|
+
const transports = opened.map((t) => behind(t, backlog, dispatched));
|
|
5841
|
+
if (bulkDispatch) {
|
|
5842
|
+
for (const t of opened) expect5(t.dispatchMany).toBeTypeOf("function");
|
|
5843
|
+
}
|
|
5844
|
+
const inner = new InMemoryStateStore5();
|
|
5845
|
+
const counts = {
|
|
5846
|
+
calls: /* @__PURE__ */ new Map(),
|
|
5847
|
+
batches: []
|
|
5848
|
+
};
|
|
5849
|
+
let turns = 0;
|
|
5850
|
+
const settled = /* @__PURE__ */ new Map();
|
|
5851
|
+
const engines = transports.map((transport) => {
|
|
5852
|
+
const engine = new WorkflowEngine6({
|
|
5853
|
+
store: counted(inner, counts),
|
|
5854
|
+
transport,
|
|
5855
|
+
reconcileMs: 0
|
|
5856
|
+
});
|
|
5857
|
+
engine.register("fan", "1", async (c) => {
|
|
5858
|
+
turns += 1;
|
|
5859
|
+
const inputs = Array.from({
|
|
5860
|
+
length: size
|
|
5861
|
+
}, (_, i) => ({
|
|
5862
|
+
i
|
|
5863
|
+
}));
|
|
5864
|
+
const opts = concurrency === void 0 ? {} : {
|
|
5865
|
+
concurrency
|
|
5866
|
+
};
|
|
5867
|
+
if (!settle2) return c.all(doubleLine, inputs, opts);
|
|
5868
|
+
const all = await c.allSettled(doubleLine, inputs, opts);
|
|
5869
|
+
return all.map((s) => s.status === "fulfilled" ? s.value : "failed");
|
|
5870
|
+
});
|
|
5871
|
+
engine.subscribe((e) => {
|
|
5872
|
+
if ((e.type === "step.completed" || e.type === "step.failed") && e.seq !== void 0) {
|
|
5873
|
+
settled.set(e.seq, (settled.get(e.seq) ?? 0) + 1);
|
|
5874
|
+
}
|
|
5875
|
+
});
|
|
5876
|
+
return engine;
|
|
5877
|
+
});
|
|
5878
|
+
try {
|
|
5879
|
+
await engines[0].start("fan", {}, "p");
|
|
5880
|
+
await until2(async () => {
|
|
5881
|
+
const status = (await inner.getRun("p"))?.status;
|
|
5882
|
+
return status === "completed" || status === "failed";
|
|
5883
|
+
}, timeoutMs - 5e3);
|
|
5884
|
+
const run2 = await inner.getRun("p");
|
|
5885
|
+
expect5(run2?.status).toBe("completed");
|
|
5886
|
+
expect5(run2?.output).toEqual(Array.from({
|
|
5887
|
+
length: size
|
|
5888
|
+
}, (_, i) => failing.has(i) ? "failed" : i * 2));
|
|
5889
|
+
expect5(settled.size).toBe(size);
|
|
5890
|
+
expect5([
|
|
5891
|
+
...settled.values()
|
|
5892
|
+
].every((n) => n === 1)).toBe(true);
|
|
5893
|
+
const barrierReads = counts.calls.get("countCheckpoints") ?? 0;
|
|
5894
|
+
expect5(Math.max(...counts.batches)).toBeGreaterThanOrEqual(minBatch);
|
|
5895
|
+
if (bulkDispatch) expect5(dispatched.one).toBe(0);
|
|
5896
|
+
if (waves === 1) expect5(barrierReads).toBeLessThanOrEqual(size / minBatch);
|
|
5897
|
+
expect5(turns).toBeLessThanOrEqual(1 + 2 * waves + failing.size);
|
|
5898
|
+
} finally {
|
|
5899
|
+
await close();
|
|
5900
|
+
}
|
|
5901
|
+
}, timeoutMs);
|
|
5902
|
+
}
|
|
5903
|
+
});
|
|
5904
|
+
}
|
|
5905
|
+
__name(runStepFanResultsContract, "runStepFanResultsContract");
|
|
5204
5906
|
export {
|
|
5205
5907
|
DURABLE_CANONICAL_COLUMNS,
|
|
5206
5908
|
MutableClock,
|
|
5207
5909
|
RUN_HISTORY_FIXTURE_VERSION,
|
|
5910
|
+
STEP_FAN_STEP,
|
|
5208
5911
|
StateStoreUnavailableError,
|
|
5209
5912
|
aggregationFixture,
|
|
5210
5913
|
assertDurableColumns,
|
|
@@ -5225,6 +5928,7 @@ export {
|
|
|
5225
5928
|
runAdmissionBackendContract,
|
|
5226
5929
|
runRunDispatchContract,
|
|
5227
5930
|
runStateStoreContract,
|
|
5931
|
+
runStepFanResultsContract,
|
|
5228
5932
|
serializeRunHistory
|
|
5229
5933
|
};
|
|
5230
5934
|
//# sourceMappingURL=index.js.map
|