fascicle 0.18.1 → 0.19.1
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/CHANGELOG.md +66 -0
- package/README.md +27 -1
- package/dist/AGENTS.md +11 -10
- package/dist/a2a.d.ts +358 -0
- package/dist/a2a.js +2234 -0
- package/dist/a2a.js.map +1 -0
- package/dist/acp.d.ts +120 -9
- package/dist/acp.js +927 -154
- package/dist/acp.js.map +1 -1
- package/dist/adapters-DYFauXE1.js +1147 -0
- package/dist/adapters-DYFauXE1.js.map +1 -0
- package/dist/adapters.d.ts +124 -36
- package/dist/adapters.js +1 -1
- package/dist/agents.d.ts +2 -2
- package/dist/agents.js +1 -1
- package/dist/{core-BH7sWpEG.js → core-xTtRZqdb.js} +217 -99
- package/dist/core-xTtRZqdb.js.map +1 -0
- package/dist/diagram_bin.js +1 -1
- package/dist/durable-CgU0kO2H.d.ts +144 -0
- package/dist/{engine-fOjYHcv6.js → engine-B_Yl7acj.js} +128 -42
- package/dist/engine-B_Yl7acj.js.map +1 -0
- package/dist/index.d.ts +9 -136
- package/dist/index.js +6 -5
- package/dist/index.js.map +1 -1
- package/dist/{invoke-7iu8db6V.js → invoke-Bbk0RuVL.js} +3 -3
- package/dist/{invoke-7iu8db6V.js.map → invoke-Bbk0RuVL.js.map} +1 -1
- package/dist/{leading_system-BeQUSAim.js → leading_system-m-x7HzbQ.js} +16 -4
- package/dist/leading_system-m-x7HzbQ.js.map +1 -0
- package/dist/mcp-D1hN5ywq.js +662 -0
- package/dist/mcp-D1hN5ywq.js.map +1 -0
- package/dist/mcp.d.ts +115 -5
- package/dist/mcp.js +2 -2
- package/dist/otel.d.ts +1 -1
- package/dist/stdio.d.ts +1 -1
- package/dist/stdio.js +2 -2
- package/dist/testing.d.ts +7 -5
- package/dist/testing.js +618 -318
- package/dist/testing.js.map +1 -1
- package/dist/{types-BUXt_zgJ.d.ts → types-BtRpSctv.d.ts} +38 -5
- package/dist/{types-Dk9tLpUq.d.ts → types-CDTW7XWB.d.ts} +2 -2
- package/dist/ui.d.ts +2 -2
- package/dist/viewer.js +2 -2
- package/dist/web.d.ts +1 -1
- package/package.json +18 -6
- package/dist/adapters-CpKpDk7r.js +0 -461
- package/dist/adapters-CpKpDk7r.js.map +0 -1
- package/dist/core-BH7sWpEG.js.map +0 -1
- package/dist/engine-fOjYHcv6.js.map +0 -1
- package/dist/leading_system-BeQUSAim.js.map +0 -1
- package/dist/mcp-CHJ88HiG.js +0 -262
- package/dist/mcp-CHJ88HiG.js.map +0 -1
package/dist/testing.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
|
-
import { n as to_json_schema, t as create_engine } from "./engine-
|
|
2
|
-
import { C as validate_schema, S as format_schema_issues, j as aborted_error } from "./core-
|
|
3
|
-
import {
|
|
1
|
+
import { n as to_json_schema, t as create_engine } from "./engine-B_Yl7acj.js";
|
|
2
|
+
import { C as validate_schema, S as format_schema_issues, j as aborted_error } from "./core-xTtRZqdb.js";
|
|
3
|
+
import { L as schema_validation_error } from "./leading_system-m-x7HzbQ.js";
|
|
4
4
|
// src/testing/assert_prefix_stable.ts
|
|
5
5
|
const ONE_AT_A_TIME = "the check reads calls that ran one at a time, so a parallel flow takes one double per branch";
|
|
6
6
|
/** A tool list as its names, in order, the way a message prints it. */
|
|
@@ -93,6 +93,7 @@ function engine_from_generate(generate) {
|
|
|
93
93
|
const DEFAULT_TTL_MS = 200;
|
|
94
94
|
const HELD_MS = 6e4;
|
|
95
95
|
const RACERS = 8;
|
|
96
|
+
const RACE_ROUNDS = 16;
|
|
96
97
|
const KEY = "k";
|
|
97
98
|
const MISSING = "never-set";
|
|
98
99
|
const NULL_KEY = "null";
|
|
@@ -112,6 +113,9 @@ const THIRD = "third";
|
|
|
112
113
|
const FRESH_SCOPE_CLAIM_REFUSED = "a claim inside a fresh scope returned false";
|
|
113
114
|
const FREE_CLAIM_REFUSED = "a claim on a key nobody holds returned false";
|
|
114
115
|
const RENEWAL_REFUSED = "the owner could not renew its own live claim";
|
|
116
|
+
const CREATE_REFUSED = "a create on a key that holds nothing was refused";
|
|
117
|
+
const FRESH_SCOPE_CREATE_REFUSED = "a create inside a fresh scope was refused";
|
|
118
|
+
const FRESH_WRITE_REFUSED = "a write on the version just read was refused";
|
|
115
119
|
const SAMPLES = [
|
|
116
120
|
{
|
|
117
121
|
candidate: "a",
|
|
@@ -245,334 +249,629 @@ async function race_for(claims, key) {
|
|
|
245
249
|
const owners = Array.from({ length: RACERS }, (_, i) => `racer-${i}`);
|
|
246
250
|
return (await Promise.all(owners.map((owner) => claims.claim(key, owner, HELD_MS)))).filter(Boolean).length;
|
|
247
251
|
}
|
|
248
|
-
|
|
252
|
+
/**
|
|
253
|
+
* The store's compare-and-set pair, or a failure naming the half that's
|
|
254
|
+
* missing. Both are called on the store itself, as `claims_of` does.
|
|
255
|
+
*/
|
|
256
|
+
function cas_of(store) {
|
|
257
|
+
const { get_versioned, set_if } = store;
|
|
258
|
+
if (get_versioned === void 0 && set_if === void 0) throw new Error("the store has neither get_versioned nor set_if");
|
|
259
|
+
if (get_versioned === void 0) throw new Error("the store offers set_if without get_versioned");
|
|
260
|
+
if (set_if === void 0) throw new Error("the store offers get_versioned without set_if");
|
|
261
|
+
return {
|
|
262
|
+
get_versioned: (key) => get_versioned.call(store, key),
|
|
263
|
+
set_if: (key, value, expected) => set_if.call(store, key, value, expected)
|
|
264
|
+
};
|
|
265
|
+
}
|
|
266
|
+
/**
|
|
267
|
+
* Read `key` with its version, failing the check when the store reports a
|
|
268
|
+
* key that holds something as absent, or hands back a version that isn't a
|
|
269
|
+
* string.
|
|
270
|
+
*/
|
|
271
|
+
async function held_version(cas, key) {
|
|
272
|
+
const read = await cas.get_versioned(key);
|
|
273
|
+
if (read === void 0) throw new Error("get_versioned read a key that holds something as absent");
|
|
274
|
+
ensure(typeof read.version === "string", `get_versioned returned the version ${show(read.version)}`);
|
|
275
|
+
return read;
|
|
276
|
+
}
|
|
277
|
+
/**
|
|
278
|
+
* The value that racer `writer` writes, which no other racer does.
|
|
279
|
+
*/
|
|
280
|
+
function racer_value(writer) {
|
|
281
|
+
return { writer };
|
|
282
|
+
}
|
|
283
|
+
/**
|
|
284
|
+
* Write `RACE_KEY` on `expected` from many writers at the same moment, and
|
|
285
|
+
* fail the check unless the store accepted exactly one of them and holds
|
|
286
|
+
* what that one wrote. `kind` names the write (a create, or a write) and
|
|
287
|
+
* `raced` says what the writers raced for, both for the failure message.
|
|
288
|
+
*/
|
|
289
|
+
async function ensure_one_winner(store, expected, kind, raced) {
|
|
290
|
+
const cas = cas_of(store);
|
|
291
|
+
const writers = Array.from({ length: RACERS }, (_, i) => i);
|
|
292
|
+
const won = await Promise.all(writers.map((i) => cas.set_if(RACE_KEY, racer_value(i), expected)));
|
|
293
|
+
const winners = writers.filter((i) => won[i]);
|
|
294
|
+
ensure(winners.length === 1, `${RACERS} ${kind}s raced ${raced} and ${winners.length} won`);
|
|
295
|
+
const value = await store.get(RACE_KEY);
|
|
296
|
+
ensure(canonical(value) === canonical(racer_value(winners[0])), `the key holds ${show(value)}, which the ${kind} that won never wrote`);
|
|
297
|
+
}
|
|
298
|
+
/**
|
|
299
|
+
* Race a write on the version `RACE_KEY` was just read at against `plain`,
|
|
300
|
+
* an unconditional write to the same key, and resolve what the key holds
|
|
301
|
+
* afterwards, or `undefined` when it holds nothing.
|
|
302
|
+
*
|
|
303
|
+
* Whichever of the two the store runs first, the unconditional write decides
|
|
304
|
+
* what's left. Run second, it lands over the conditional write. Run first,
|
|
305
|
+
* it moves the version, and the conditional write is refused. So the
|
|
306
|
+
* conditional write may report either answer, and its value may never be
|
|
307
|
+
* what the key ends up holding. Even rounds start the conditional write
|
|
308
|
+
* first and odd rounds start the unconditional one first, since a store
|
|
309
|
+
* that isn't atomic tends to lose only one of the two orders.
|
|
310
|
+
*/
|
|
311
|
+
async function race_unconditional(store, round, plain) {
|
|
312
|
+
const cas = cas_of(store);
|
|
313
|
+
await store.set(RACE_KEY, {
|
|
314
|
+
round,
|
|
315
|
+
by: "before"
|
|
316
|
+
});
|
|
317
|
+
const read = await held_version(cas, RACE_KEY);
|
|
318
|
+
const conditional = () => cas.set_if(RACE_KEY, raced_value(round), read.version);
|
|
319
|
+
await (round % 2 === 0 ? Promise.all([conditional(), plain()]) : Promise.all([plain(), conditional()]));
|
|
320
|
+
return cas.get_versioned(RACE_KEY);
|
|
321
|
+
}
|
|
322
|
+
/**
|
|
323
|
+
* The value the conditional write of one round writes.
|
|
324
|
+
*/
|
|
325
|
+
function raced_value(round) {
|
|
326
|
+
return {
|
|
327
|
+
round,
|
|
328
|
+
by: "set_if"
|
|
329
|
+
};
|
|
330
|
+
}
|
|
331
|
+
const CONTRACT_CHECKS = [
|
|
249
332
|
{
|
|
250
|
-
|
|
251
|
-
|
|
252
|
-
|
|
253
|
-
|
|
254
|
-
|
|
255
|
-
|
|
256
|
-
|
|
257
|
-
|
|
258
|
-
|
|
259
|
-
|
|
260
|
-
|
|
261
|
-
|
|
262
|
-
|
|
263
|
-
|
|
264
|
-
|
|
265
|
-
|
|
266
|
-
|
|
267
|
-
|
|
268
|
-
|
|
269
|
-
|
|
270
|
-
|
|
271
|
-
|
|
272
|
-
|
|
273
|
-
|
|
274
|
-
|
|
275
|
-
|
|
276
|
-
|
|
277
|
-
|
|
278
|
-
|
|
279
|
-
|
|
280
|
-
|
|
281
|
-
|
|
282
|
-
|
|
283
|
-
|
|
284
|
-
|
|
285
|
-
|
|
286
|
-
|
|
287
|
-
|
|
288
|
-
|
|
289
|
-
|
|
290
|
-
|
|
291
|
-
|
|
292
|
-
|
|
293
|
-
|
|
294
|
-
|
|
295
|
-
|
|
296
|
-
|
|
297
|
-
|
|
298
|
-
|
|
299
|
-
|
|
300
|
-
|
|
301
|
-
|
|
302
|
-
|
|
303
|
-
|
|
304
|
-
|
|
305
|
-
|
|
306
|
-
|
|
307
|
-
|
|
308
|
-
|
|
309
|
-
|
|
310
|
-
|
|
311
|
-
|
|
312
|
-
|
|
313
|
-
|
|
314
|
-
|
|
315
|
-
|
|
316
|
-
|
|
317
|
-
|
|
318
|
-
|
|
319
|
-
|
|
320
|
-
|
|
321
|
-
|
|
333
|
+
name: "a missing key reads as a miss",
|
|
334
|
+
run: async (store) => {
|
|
335
|
+
const value = await store.get(MISSING);
|
|
336
|
+
ensure(is_miss(value), `get on a key nobody set returned ${show(value)}`);
|
|
337
|
+
}
|
|
338
|
+
},
|
|
339
|
+
{
|
|
340
|
+
name: "values round-trip as JSON",
|
|
341
|
+
run: async (store) => {
|
|
342
|
+
await Promise.all(SAMPLES.map((sample, i) => store.set(`sample-${i}`, sample)));
|
|
343
|
+
const read = await Promise.all(SAMPLES.map((_, i) => store.get(`sample-${i}`)));
|
|
344
|
+
SAMPLES.forEach((sample, i) => {
|
|
345
|
+
ensure(canonical(read[i]) === canonical(sample), `set ${show(sample)} and got back ${show(read[i])}`);
|
|
346
|
+
});
|
|
347
|
+
}
|
|
348
|
+
},
|
|
349
|
+
{
|
|
350
|
+
name: "set overwrites a value",
|
|
351
|
+
run: async (store) => {
|
|
352
|
+
await store.set(KEY, { v: 1 });
|
|
353
|
+
await store.set(KEY, { v: 2 });
|
|
354
|
+
const value = await store.get(KEY);
|
|
355
|
+
ensure(canonical(value) === canonical({ v: 2 }), `a second set lost to the first: ${show(value)}`);
|
|
356
|
+
}
|
|
357
|
+
},
|
|
358
|
+
{
|
|
359
|
+
name: "delete removes a value",
|
|
360
|
+
run: async (store) => {
|
|
361
|
+
await store.set(KEY, { v: 1 });
|
|
362
|
+
await store.delete(KEY);
|
|
363
|
+
const value = await store.get(KEY);
|
|
364
|
+
ensure(is_miss(value), `get after delete returned ${show(value)}`);
|
|
365
|
+
}
|
|
366
|
+
},
|
|
367
|
+
{
|
|
368
|
+
name: "deleting a missing key resolves",
|
|
369
|
+
run: async (store) => {
|
|
370
|
+
await store.delete(MISSING);
|
|
371
|
+
}
|
|
372
|
+
},
|
|
373
|
+
{
|
|
374
|
+
name: "a stored null or undefined reads as a miss",
|
|
375
|
+
run: async (store) => {
|
|
376
|
+
await store.set(NULL_KEY, null);
|
|
377
|
+
await store.set(UNDEFINED_KEY, void 0);
|
|
378
|
+
ensure(is_miss(await store.get(NULL_KEY)), "a stored null read back as a hit");
|
|
379
|
+
ensure(is_miss(await store.get(UNDEFINED_KEY)), "a stored undefined read back as a hit");
|
|
380
|
+
}
|
|
381
|
+
},
|
|
382
|
+
{
|
|
383
|
+
name: "keys that encode alike stay apart",
|
|
384
|
+
run: async (store) => {
|
|
385
|
+
await Promise.all(LOOKALIKES.map((key, i) => store.set(key, i)));
|
|
386
|
+
const read = await Promise.all(LOOKALIKES.map((key) => store.get(key)));
|
|
387
|
+
LOOKALIKES.forEach((key, i) => {
|
|
388
|
+
ensure(read[i] === i, `key ${show(key)} read back ${show(read[i])}, another key's value`);
|
|
389
|
+
});
|
|
390
|
+
}
|
|
391
|
+
},
|
|
392
|
+
{
|
|
393
|
+
name: "racing writes leave one whole value",
|
|
394
|
+
run: async (store) => {
|
|
395
|
+
const writes = Array.from({ length: RACERS }, (_, i) => ({
|
|
396
|
+
writer: i,
|
|
397
|
+
body: "x".repeat(4096 + i)
|
|
398
|
+
}));
|
|
399
|
+
await Promise.all(writes.map((write) => store.set(RACE_KEY, write)));
|
|
400
|
+
const value = await store.get(RACE_KEY);
|
|
401
|
+
ensure(writes.some((write) => canonical(write) === canonical(value)), `after ${RACERS} racing sets, get returned ${show(value)}, which none of them wrote`);
|
|
402
|
+
}
|
|
403
|
+
}
|
|
404
|
+
];
|
|
405
|
+
const DAMAGE_CHECK = {
|
|
406
|
+
name: "a damaged value reads as a miss",
|
|
407
|
+
run: async (store, env) => {
|
|
408
|
+
await store.set(DAMAGED_KEY, { ok: true });
|
|
409
|
+
await env.corrupt(store, DAMAGED_KEY);
|
|
410
|
+
let value;
|
|
411
|
+
try {
|
|
412
|
+
value = await store.get(DAMAGED_KEY);
|
|
413
|
+
} catch (err) {
|
|
414
|
+
throw new Error(`get threw on a damaged value instead of missing: ${String(err)}`, { cause: err });
|
|
415
|
+
}
|
|
416
|
+
ensure(is_miss(value), `get on a damaged value returned ${show(value)}`);
|
|
417
|
+
}
|
|
418
|
+
};
|
|
419
|
+
const SCOPE_CHECKS = [
|
|
420
|
+
{
|
|
421
|
+
name: "a scope is apart from its parent",
|
|
422
|
+
run: async (store) => {
|
|
423
|
+
const child = scope_of(store, CHILD);
|
|
424
|
+
await store.set(KEY, "parent");
|
|
425
|
+
ensure(is_miss(await child.get(KEY)), "a scope read its parent's value");
|
|
426
|
+
await child.set(KEY, "child");
|
|
427
|
+
ensure(await store.get(KEY) === "parent", "a write in a scope changed its parent's value");
|
|
428
|
+
ensure(await child.get(KEY) === "child", "a scope lost its own value");
|
|
429
|
+
}
|
|
430
|
+
},
|
|
431
|
+
{
|
|
432
|
+
name: "one prefix reaches the same data, another prefix does not",
|
|
433
|
+
run: async (store) => {
|
|
434
|
+
await scope_of(store, A).set(KEY, "a");
|
|
435
|
+
ensure(await scope_of(store, A).get(KEY) === "a", "reopening a scope lost its value");
|
|
436
|
+
ensure(is_miss(await scope_of(store, B).get(KEY)), "scope 'b' read a value set in scope 'a'");
|
|
437
|
+
}
|
|
438
|
+
},
|
|
439
|
+
{
|
|
440
|
+
name: "prefixes that encode alike stay apart",
|
|
441
|
+
run: async (store) => {
|
|
442
|
+
await Promise.all(LOOKALIKES.map((prefix, i) => scope_of(store, prefix).set(KEY, i)));
|
|
443
|
+
const read = await Promise.all(LOOKALIKES.map((prefix) => scope_of(store, prefix).get(KEY)));
|
|
444
|
+
LOOKALIKES.forEach((prefix, i) => {
|
|
445
|
+
ensure(read[i] === i, `scope ${show(prefix)} read back ${show(read[i])}, another scope's`);
|
|
446
|
+
});
|
|
447
|
+
}
|
|
448
|
+
},
|
|
449
|
+
{
|
|
450
|
+
name: "nested scopes stay apart from look-alike prefixes",
|
|
451
|
+
run: async (store) => {
|
|
452
|
+
await scope_of(store, A).scope(B).set(KEY, "nested");
|
|
453
|
+
const read = await Promise.all(FLATTENED.map((prefix) => scope_of(store, prefix).get(KEY)));
|
|
454
|
+
FLATTENED.forEach((prefix, i) => {
|
|
455
|
+
ensure(is_miss(read[i]), `scope ${show(prefix)} read the value of scope 'b' in scope 'a'`);
|
|
456
|
+
});
|
|
457
|
+
const a = scope_of(store, A);
|
|
458
|
+
ensure(is_miss(await a.get(KEY)), "a nested scope's value showed up in its parent");
|
|
459
|
+
ensure(await a.scope(B).get(KEY) === "nested", "reopening a nested scope lost its value");
|
|
460
|
+
}
|
|
461
|
+
},
|
|
462
|
+
{
|
|
463
|
+
name: "clear empties a scope and nothing else",
|
|
464
|
+
run: async (store) => {
|
|
465
|
+
const a = scope_of(store, A);
|
|
466
|
+
await Promise.all([
|
|
467
|
+
store.set(KEY, "root"),
|
|
468
|
+
a.set(KEY, "a"),
|
|
469
|
+
a.scope(INNER).set(KEY, "inner"),
|
|
470
|
+
scope_of(store, B).set(KEY, "b")
|
|
471
|
+
]);
|
|
472
|
+
await a.clear();
|
|
473
|
+
ensure(is_miss(await a.get(KEY)), "a value survived clear");
|
|
474
|
+
ensure(is_miss(await a.scope(INNER).get(KEY)), "a nested scope's value survived clear");
|
|
475
|
+
ensure(await scope_of(store, B).get(KEY) === "b", "clear removed a sibling's value");
|
|
476
|
+
ensure(await store.get(KEY) === "root", "clear removed the parent's value");
|
|
477
|
+
await a.set(KEY, "again");
|
|
478
|
+
ensure(await a.get(KEY) === "again", "a cleared scope refused a new value");
|
|
479
|
+
}
|
|
480
|
+
},
|
|
481
|
+
{
|
|
482
|
+
name: "clear leaves look-alike scopes alone",
|
|
483
|
+
run: async (store) => {
|
|
484
|
+
await Promise.all(BESIDE_A.map((prefix, i) => scope_of(store, prefix).set(KEY, i)));
|
|
485
|
+
await scope_of(store, A).clear();
|
|
486
|
+
const read = await Promise.all(BESIDE_A.map((prefix) => scope_of(store, prefix).get(KEY)));
|
|
487
|
+
BESIDE_A.forEach((prefix, i) => {
|
|
488
|
+
ensure(read[i] === i, `clearing scope 'a' emptied scope ${show(prefix)}`);
|
|
489
|
+
});
|
|
490
|
+
}
|
|
491
|
+
},
|
|
492
|
+
{
|
|
493
|
+
name: "clearing an empty scope resolves",
|
|
494
|
+
run: async (store) => {
|
|
495
|
+
await scope_of(store, UNUSED).clear();
|
|
496
|
+
}
|
|
497
|
+
}
|
|
498
|
+
];
|
|
499
|
+
const SCOPED_CLAIM_CHECKS = [
|
|
500
|
+
{
|
|
501
|
+
name: "scopes keep the claim capability",
|
|
502
|
+
run: async (store) => {
|
|
503
|
+
ensure(await claims_of(scope_of(store, A)).claim(KEY, FIRST, HELD_MS), FRESH_SCOPE_CLAIM_REFUSED);
|
|
504
|
+
}
|
|
505
|
+
},
|
|
506
|
+
{
|
|
507
|
+
name: "claims in different scopes stay apart",
|
|
508
|
+
run: async (store) => {
|
|
509
|
+
const first = await claims_of(scope_of(store, A)).claim(KEY, FIRST, HELD_MS);
|
|
510
|
+
const second = await claims_of(scope_of(store, B)).claim(KEY, SECOND, HELD_MS);
|
|
511
|
+
const third = await claims_of(store).claim(KEY, THIRD, HELD_MS);
|
|
512
|
+
ensure(first, FRESH_SCOPE_CLAIM_REFUSED);
|
|
513
|
+
ensure(second, "scope 'b' couldn't claim a key held in scope 'a'");
|
|
514
|
+
ensure(third, "the parent couldn't claim a key held in a scope");
|
|
515
|
+
}
|
|
516
|
+
},
|
|
517
|
+
{
|
|
518
|
+
name: "clear drops the claims under a scope",
|
|
519
|
+
run: async (store) => {
|
|
520
|
+
const a = scope_of(store, A);
|
|
521
|
+
ensure(await claims_of(a).claim(KEY, FIRST, HELD_MS), FRESH_SCOPE_CLAIM_REFUSED);
|
|
522
|
+
await a.clear();
|
|
523
|
+
ensure(await claims_of(a).claim(KEY, SECOND, HELD_MS), "a claim survived clear");
|
|
524
|
+
}
|
|
525
|
+
}
|
|
526
|
+
];
|
|
527
|
+
const CLAIM_CHECKS = [
|
|
528
|
+
{
|
|
529
|
+
name: "claim comes with release",
|
|
530
|
+
run: async (store) => {
|
|
531
|
+
claims_of(store);
|
|
532
|
+
}
|
|
533
|
+
},
|
|
534
|
+
{
|
|
535
|
+
name: "a free key can be claimed",
|
|
536
|
+
run: async (store) => {
|
|
537
|
+
ensure(await claims_of(store).claim(KEY, FIRST, HELD_MS), FREE_CLAIM_REFUSED);
|
|
538
|
+
}
|
|
539
|
+
},
|
|
540
|
+
{
|
|
541
|
+
name: "a held key refuses another owner",
|
|
542
|
+
run: async (store) => {
|
|
543
|
+
const claims = claims_of(store);
|
|
544
|
+
await claims.claim(KEY, FIRST, HELD_MS);
|
|
545
|
+
ensure(!await claims.claim(KEY, SECOND, HELD_MS), "a second owner claimed a key the first still holds");
|
|
546
|
+
}
|
|
547
|
+
},
|
|
548
|
+
{
|
|
549
|
+
name: "the owner can renew its claim",
|
|
550
|
+
run: async (store) => {
|
|
551
|
+
const claims = claims_of(store);
|
|
552
|
+
await claims.claim(KEY, FIRST, HELD_MS);
|
|
553
|
+
ensure(await claims.claim(KEY, FIRST, HELD_MS), RENEWAL_REFUSED);
|
|
554
|
+
}
|
|
555
|
+
},
|
|
556
|
+
{
|
|
557
|
+
name: "release lets another owner in",
|
|
558
|
+
run: async (store) => {
|
|
559
|
+
const claims = claims_of(store);
|
|
560
|
+
await claims.claim(KEY, FIRST, HELD_MS);
|
|
561
|
+
await claims.release(KEY, FIRST);
|
|
562
|
+
ensure(await claims.claim(KEY, SECOND, HELD_MS), "a released key refused the next owner");
|
|
563
|
+
}
|
|
564
|
+
},
|
|
565
|
+
{
|
|
566
|
+
name: "release by another owner changes nothing",
|
|
567
|
+
run: async (store) => {
|
|
568
|
+
const claims = claims_of(store);
|
|
569
|
+
await claims.claim(KEY, FIRST, HELD_MS);
|
|
570
|
+
await claims.release(KEY, SECOND);
|
|
571
|
+
ensure(!await claims.claim(KEY, SECOND, HELD_MS), "a release by a non-owner freed the owner's claim");
|
|
572
|
+
}
|
|
573
|
+
},
|
|
574
|
+
{
|
|
575
|
+
name: "releasing a key nobody holds resolves",
|
|
576
|
+
run: async (store) => {
|
|
577
|
+
await claims_of(store).release(UNCLAIMED, FIRST);
|
|
578
|
+
}
|
|
579
|
+
},
|
|
580
|
+
{
|
|
581
|
+
name: "claims and values stay apart",
|
|
582
|
+
run: async (store) => {
|
|
583
|
+
const claims = claims_of(store);
|
|
584
|
+
await store.set(KEY, "value");
|
|
585
|
+
ensure(await claims.claim(KEY, FIRST, HELD_MS), "a key that holds a value refused a claim");
|
|
586
|
+
ensure(await store.get(KEY) === "value", "claiming a key changed its value");
|
|
587
|
+
await store.delete(KEY);
|
|
588
|
+
ensure(!await claims.claim(KEY, SECOND, HELD_MS), "deleting a value released the claim on the same key");
|
|
589
|
+
await claims.claim(CLAIMED_ONLY, FIRST, HELD_MS);
|
|
590
|
+
ensure(is_miss(await store.get(CLAIMED_ONLY)), "claiming a key gave it a value");
|
|
591
|
+
}
|
|
592
|
+
},
|
|
593
|
+
{
|
|
594
|
+
name: "different keys are claimed apart",
|
|
595
|
+
run: async (store) => {
|
|
596
|
+
const claims = claims_of(store);
|
|
597
|
+
ensure(await claims.claim(A, FIRST, HELD_MS), FREE_CLAIM_REFUSED);
|
|
598
|
+
ensure(await claims.claim(B, SECOND, HELD_MS), "a claim on 'a' blocked a claim on 'b'");
|
|
599
|
+
}
|
|
600
|
+
},
|
|
601
|
+
{
|
|
602
|
+
name: "exactly one racing claimer wins a free key",
|
|
603
|
+
run: async (store) => {
|
|
604
|
+
const winners = await race_for(claims_of(store), KEY);
|
|
605
|
+
ensure(winners === 1, `${RACERS} owners raced for a free key and ${winners} won`);
|
|
606
|
+
}
|
|
607
|
+
},
|
|
608
|
+
{
|
|
609
|
+
name: "an expired claim passes to another owner",
|
|
610
|
+
run: async (store, env) => {
|
|
611
|
+
const claims = claims_of(store);
|
|
612
|
+
await claims.claim(KEY, FIRST, env.ttl_ms);
|
|
613
|
+
await sleep(env.ttl_ms * 2);
|
|
614
|
+
ensure(await claims.claim(KEY, SECOND, HELD_MS), `a claim was still held after its ${env.ttl_ms}ms ran out`);
|
|
615
|
+
ensure(!await claims.claim(KEY, FIRST, HELD_MS), "the first owner took back a claim that had passed to another");
|
|
616
|
+
}
|
|
617
|
+
},
|
|
618
|
+
{
|
|
619
|
+
name: "exactly one racing claimer takes an expired claim",
|
|
620
|
+
run: async (store, env) => {
|
|
621
|
+
const claims = claims_of(store);
|
|
622
|
+
await claims.claim(KEY, FIRST, env.ttl_ms);
|
|
623
|
+
await sleep(env.ttl_ms * 2);
|
|
624
|
+
const winners = await race_for(claims, KEY);
|
|
625
|
+
ensure(winners === 1, `${RACERS} owners raced for an expired claim and ${winners} won`);
|
|
626
|
+
}
|
|
627
|
+
},
|
|
628
|
+
{
|
|
629
|
+
name: "renewing restarts the clock",
|
|
630
|
+
run: async (store, env) => {
|
|
631
|
+
const claims = claims_of(store);
|
|
632
|
+
const started = Date.now();
|
|
633
|
+
await claims.claim(KEY, FIRST, env.ttl_ms);
|
|
634
|
+
await sleep(env.ttl_ms / 2);
|
|
635
|
+
const renewed = Date.now();
|
|
636
|
+
ensure(await claims.claim(KEY, FIRST, env.ttl_ms), RENEWAL_REFUSED);
|
|
637
|
+
await sleep(Math.max(0, started + env.ttl_ms * 1.2 - Date.now()));
|
|
638
|
+
const second = await claims.claim(KEY, SECOND, HELD_MS);
|
|
639
|
+
if (Date.now() >= renewed + env.ttl_ms) return;
|
|
640
|
+
ensure(!second, "a renewed claim expired on its original schedule");
|
|
641
|
+
}
|
|
642
|
+
}
|
|
643
|
+
];
|
|
644
|
+
const CAS_CHECKS = [
|
|
645
|
+
{
|
|
646
|
+
name: "get_versioned comes with set_if",
|
|
647
|
+
run: async (store) => {
|
|
648
|
+
cas_of(store);
|
|
649
|
+
}
|
|
650
|
+
},
|
|
651
|
+
{
|
|
652
|
+
name: "a missing key has no version",
|
|
653
|
+
run: async (store) => {
|
|
654
|
+
const read = await cas_of(store).get_versioned(MISSING);
|
|
655
|
+
ensure(read === void 0, `get_versioned on a key nobody set returned ${show(read)}`);
|
|
656
|
+
}
|
|
657
|
+
},
|
|
658
|
+
{
|
|
659
|
+
name: "a stored null reads with a version",
|
|
660
|
+
run: async (store) => {
|
|
661
|
+
const cas = cas_of(store);
|
|
662
|
+
await store.set(NULL_KEY, null);
|
|
663
|
+
const read = await held_version(cas, NULL_KEY);
|
|
664
|
+
ensure(is_miss(read.value), `a stored null read back as ${show(read.value)}`);
|
|
665
|
+
ensure(await cas.set_if(NULL_KEY, { v: 1 }, read.version), "a write on the version of a stored null was refused");
|
|
666
|
+
const value = await store.get(NULL_KEY);
|
|
667
|
+
ensure(canonical(value) === canonical({ v: 1 }), `the write over a null left ${show(value)}`);
|
|
668
|
+
}
|
|
669
|
+
},
|
|
670
|
+
{
|
|
671
|
+
name: "a create lands on an absent key",
|
|
672
|
+
run: async (store) => {
|
|
673
|
+
ensure(await cas_of(store).set_if(KEY, { v: 1 }, null), CREATE_REFUSED);
|
|
674
|
+
const value = await store.get(KEY);
|
|
675
|
+
ensure(canonical(value) === canonical({ v: 1 }), `a create that won left ${show(value)}`);
|
|
676
|
+
}
|
|
677
|
+
},
|
|
678
|
+
{
|
|
679
|
+
name: "a create refuses a key that holds anything",
|
|
680
|
+
run: async (store) => {
|
|
681
|
+
const cas = cas_of(store);
|
|
682
|
+
await store.set(KEY, { v: 1 });
|
|
683
|
+
ensure(!await cas.set_if(KEY, { v: 2 }, null), "a create landed on a key that holds a value");
|
|
684
|
+
const value = await store.get(KEY);
|
|
685
|
+
ensure(canonical(value) === canonical({ v: 1 }), `a refused create left ${show(value)}`);
|
|
686
|
+
await store.set(NULL_KEY, null);
|
|
687
|
+
ensure(!await cas.set_if(NULL_KEY, { v: 2 }, null), "a create landed on a key that holds a stored null");
|
|
688
|
+
}
|
|
689
|
+
},
|
|
690
|
+
{
|
|
691
|
+
name: "exactly one racing create wins",
|
|
692
|
+
run: (store) => ensure_one_winner(store, null, "create", "for an absent key")
|
|
693
|
+
},
|
|
694
|
+
{
|
|
695
|
+
name: "a write on the version it read lands and moves the version",
|
|
696
|
+
run: async (store) => {
|
|
697
|
+
const cas = cas_of(store);
|
|
698
|
+
await store.set(KEY, { v: 1 });
|
|
699
|
+
const before = await held_version(cas, KEY);
|
|
700
|
+
ensure(canonical(before.value) === canonical({ v: 1 }), `get_versioned read ${show(before.value)}`);
|
|
701
|
+
ensure(await cas.set_if(KEY, { v: 2 }, before.version), FRESH_WRITE_REFUSED);
|
|
702
|
+
const after = await held_version(cas, KEY);
|
|
703
|
+
ensure(canonical(after.value) === canonical({ v: 2 }), `the write left ${show(after.value)}`);
|
|
704
|
+
ensure(after.version !== before.version, "a write that landed left the version where it was");
|
|
705
|
+
}
|
|
706
|
+
},
|
|
707
|
+
{
|
|
708
|
+
name: "a write on a stale version is refused and changes nothing",
|
|
709
|
+
run: async (store) => {
|
|
710
|
+
const cas = cas_of(store);
|
|
711
|
+
await store.set(KEY, { v: 1 });
|
|
712
|
+
const stale = await held_version(cas, KEY);
|
|
713
|
+
ensure(await cas.set_if(KEY, { v: 2 }, stale.version), FRESH_WRITE_REFUSED);
|
|
714
|
+
const current = await held_version(cas, KEY);
|
|
715
|
+
ensure(!await cas.set_if(KEY, { v: 3 }, stale.version), "a write landed on a version another write had already replaced");
|
|
716
|
+
const after = await held_version(cas, KEY);
|
|
717
|
+
ensure(canonical(after.value) === canonical({ v: 2 }), `a refused write left ${show(after.value)}`);
|
|
718
|
+
ensure(after.version === current.version, "a refused write moved the version");
|
|
719
|
+
}
|
|
720
|
+
},
|
|
721
|
+
{
|
|
722
|
+
name: "exactly one racing write on one version wins",
|
|
723
|
+
run: async (store) => {
|
|
724
|
+
await store.set(RACE_KEY, { v: 0 });
|
|
725
|
+
await ensure_one_winner(store, (await held_version(cas_of(store), RACE_KEY)).version, "write", "on one version");
|
|
726
|
+
}
|
|
727
|
+
},
|
|
728
|
+
{
|
|
729
|
+
name: "set and delete move the version",
|
|
730
|
+
run: async (store) => {
|
|
731
|
+
const cas = cas_of(store);
|
|
732
|
+
await store.set(KEY, { v: 1 });
|
|
733
|
+
const first = await held_version(cas, KEY);
|
|
734
|
+
await store.set(KEY, { v: 2 });
|
|
735
|
+
const second = await held_version(cas, KEY);
|
|
736
|
+
ensure(second.version !== first.version, "a set left the version where it was");
|
|
737
|
+
ensure(!await cas.set_if(KEY, { v: 3 }, first.version), "a write landed on a version a set had already replaced");
|
|
738
|
+
await store.delete(KEY);
|
|
739
|
+
const gone = await cas.get_versioned(KEY);
|
|
740
|
+
ensure(gone === void 0, `get_versioned after delete returned ${show(gone)}`);
|
|
741
|
+
ensure(!await cas.set_if(KEY, { v: 3 }, second.version), "a write landed on the version of a value that was deleted");
|
|
742
|
+
ensure(is_miss(await store.get(KEY)), "a refused write brought a deleted value back");
|
|
743
|
+
}
|
|
744
|
+
},
|
|
745
|
+
{
|
|
746
|
+
name: "a set that races a write on a version is the one that lasts",
|
|
747
|
+
run: async (store) => {
|
|
748
|
+
for (let round = 0; round < RACE_ROUNDS; round += 1) {
|
|
749
|
+
const written = {
|
|
750
|
+
round,
|
|
751
|
+
by: "set"
|
|
752
|
+
};
|
|
753
|
+
const left = await race_unconditional(store, round, () => store.set(RACE_KEY, written));
|
|
754
|
+
ensure(canonical(left?.value) === canonical(written), `a set raced a write on a version and the key holds ${show(left?.value)}, not what the set wrote`);
|
|
322
755
|
}
|
|
323
|
-
|
|
324
|
-
applies: () => true
|
|
756
|
+
}
|
|
325
757
|
},
|
|
326
758
|
{
|
|
327
|
-
|
|
328
|
-
|
|
329
|
-
|
|
330
|
-
await store
|
|
331
|
-
|
|
332
|
-
let value;
|
|
333
|
-
try {
|
|
334
|
-
value = await store.get(DAMAGED_KEY);
|
|
335
|
-
} catch (err) {
|
|
336
|
-
throw new Error(`get threw on a damaged value instead of missing: ${String(err)}`, { cause: err });
|
|
337
|
-
}
|
|
338
|
-
ensure(is_miss(value), `get on a damaged value returned ${show(value)}`);
|
|
759
|
+
name: "a delete that races a write on a version leaves the key absent",
|
|
760
|
+
run: async (store) => {
|
|
761
|
+
for (let round = 0; round < RACE_ROUNDS; round += 1) {
|
|
762
|
+
const left = await race_unconditional(store, round, () => store.delete(RACE_KEY));
|
|
763
|
+
ensure(left === void 0, `a delete raced a write on a version and the key holds ${show(left?.value)}`);
|
|
339
764
|
}
|
|
340
|
-
}
|
|
765
|
+
}
|
|
766
|
+
},
|
|
767
|
+
{
|
|
768
|
+
name: "a create works again after a delete",
|
|
769
|
+
run: async (store) => {
|
|
770
|
+
const cas = cas_of(store);
|
|
771
|
+
ensure(await cas.set_if(KEY, { v: 1 }, null), CREATE_REFUSED);
|
|
772
|
+
await store.delete(KEY);
|
|
773
|
+
ensure(await cas.set_if(KEY, { v: 2 }, null), "a create was refused on a key that was deleted");
|
|
774
|
+
const value = await store.get(KEY);
|
|
775
|
+
ensure(canonical(value) === canonical({ v: 2 }), `the second create left ${show(value)}`);
|
|
776
|
+
}
|
|
777
|
+
}
|
|
778
|
+
];
|
|
779
|
+
const CAS_DAMAGE_CHECK = {
|
|
780
|
+
name: "a damaged value reads with a version",
|
|
781
|
+
run: async (store, env) => {
|
|
782
|
+
const cas = cas_of(store);
|
|
783
|
+
await store.set(DAMAGED_KEY, { ok: true });
|
|
784
|
+
await env.corrupt(store, DAMAGED_KEY);
|
|
785
|
+
let read;
|
|
786
|
+
try {
|
|
787
|
+
read = await cas.get_versioned(DAMAGED_KEY);
|
|
788
|
+
} catch (err) {
|
|
789
|
+
throw new Error(`get_versioned threw on a damaged value: ${String(err)}`, { cause: err });
|
|
790
|
+
}
|
|
791
|
+
if (read === void 0) throw new Error("get_versioned read a damaged value as an absent key");
|
|
792
|
+
ensure(is_miss(read.value), `get_versioned on a damaged value returned ${show(read.value)}`);
|
|
793
|
+
ensure(await cas.set_if(DAMAGED_KEY, { ok: false }, read.version), "a write on the version of a damaged value was refused");
|
|
794
|
+
const value = await store.get(DAMAGED_KEY);
|
|
795
|
+
ensure(canonical(value) === canonical({ ok: false }), `the write over the damage left ${show(value)}`);
|
|
796
|
+
}
|
|
797
|
+
};
|
|
798
|
+
const SCOPED_CAS_CHECKS = [
|
|
799
|
+
{
|
|
800
|
+
name: "scopes keep the compare-and-set capability",
|
|
801
|
+
run: async (store) => {
|
|
802
|
+
const cas = cas_of(scope_of(store, A));
|
|
803
|
+
ensure(await cas.set_if(KEY, { v: 1 }, null), FRESH_SCOPE_CREATE_REFUSED);
|
|
804
|
+
const read = await held_version(cas, KEY);
|
|
805
|
+
ensure(canonical(read.value) === canonical({ v: 1 }), `a scope read back ${show(read.value)}`);
|
|
806
|
+
ensure(await cas_of(store).get_versioned(KEY) === void 0, "a create in a scope showed up under its parent's key");
|
|
807
|
+
}
|
|
808
|
+
},
|
|
809
|
+
{
|
|
810
|
+
name: "a version from one scope satisfies nothing in another",
|
|
811
|
+
run: async (store) => {
|
|
812
|
+
const a = scope_of(store, A);
|
|
813
|
+
const b = scope_of(store, B);
|
|
814
|
+
await a.set(KEY, { v: 1 });
|
|
815
|
+
await b.set(KEY, { v: 2 });
|
|
816
|
+
const in_a = await held_version(cas_of(a), KEY);
|
|
817
|
+
ensure(!await cas_of(b).set_if(KEY, { v: 3 }, in_a.version), "a write in scope 'b' landed on a version read in scope 'a'");
|
|
818
|
+
const value = await b.get(KEY);
|
|
819
|
+
ensure(canonical(value) === canonical({ v: 2 }), `the refused write left ${show(value)} in scope 'b'`);
|
|
820
|
+
ensure(await cas_of(scope_of(store, CHILD)).set_if(KEY, { v: 4 }, null), "a create was refused because another scope holds the key");
|
|
821
|
+
}
|
|
822
|
+
},
|
|
823
|
+
{
|
|
824
|
+
name: "a create works again after a clear",
|
|
825
|
+
run: async (store) => {
|
|
826
|
+
const a = scope_of(store, A);
|
|
827
|
+
const cas = cas_of(a);
|
|
828
|
+
ensure(await cas.set_if(KEY, { v: 1 }, null), FRESH_SCOPE_CREATE_REFUSED);
|
|
829
|
+
await a.clear();
|
|
830
|
+
const gone = await cas.get_versioned(KEY);
|
|
831
|
+
ensure(gone === void 0, `get_versioned after clear returned ${show(gone)}`);
|
|
832
|
+
ensure(await cas.set_if(KEY, { v: 2 }, null), "a create was refused on a key that was cleared");
|
|
833
|
+
}
|
|
834
|
+
}
|
|
835
|
+
];
|
|
836
|
+
/**
|
|
837
|
+
* True when the store offers either half of the compare-and-set, which is
|
|
838
|
+
* when its checks run. A store with only one half fails the first of them.
|
|
839
|
+
*/
|
|
840
|
+
function has_cas(store) {
|
|
841
|
+
return store.get_versioned !== void 0 || store.set_if !== void 0;
|
|
842
|
+
}
|
|
843
|
+
const SUITES = [
|
|
844
|
+
{
|
|
845
|
+
checks: CONTRACT_CHECKS,
|
|
846
|
+
applies: () => true
|
|
847
|
+
},
|
|
848
|
+
{
|
|
849
|
+
checks: [DAMAGE_CHECK],
|
|
341
850
|
applies: (_, options) => options.corrupt !== void 0
|
|
342
851
|
},
|
|
343
852
|
{
|
|
344
|
-
checks:
|
|
345
|
-
{
|
|
346
|
-
name: "a scope is apart from its parent",
|
|
347
|
-
run: async (store) => {
|
|
348
|
-
const child = scope_of(store, CHILD);
|
|
349
|
-
await store.set(KEY, "parent");
|
|
350
|
-
ensure(is_miss(await child.get(KEY)), "a scope read its parent's value");
|
|
351
|
-
await child.set(KEY, "child");
|
|
352
|
-
ensure(await store.get(KEY) === "parent", "a write in a scope changed its parent's value");
|
|
353
|
-
ensure(await child.get(KEY) === "child", "a scope lost its own value");
|
|
354
|
-
}
|
|
355
|
-
},
|
|
356
|
-
{
|
|
357
|
-
name: "one prefix reaches the same data, another prefix does not",
|
|
358
|
-
run: async (store) => {
|
|
359
|
-
await scope_of(store, A).set(KEY, "a");
|
|
360
|
-
ensure(await scope_of(store, A).get(KEY) === "a", "reopening a scope lost its value");
|
|
361
|
-
ensure(is_miss(await scope_of(store, B).get(KEY)), "scope 'b' read a value set in scope 'a'");
|
|
362
|
-
}
|
|
363
|
-
},
|
|
364
|
-
{
|
|
365
|
-
name: "prefixes that encode alike stay apart",
|
|
366
|
-
run: async (store) => {
|
|
367
|
-
await Promise.all(LOOKALIKES.map((prefix, i) => scope_of(store, prefix).set(KEY, i)));
|
|
368
|
-
const read = await Promise.all(LOOKALIKES.map((prefix) => scope_of(store, prefix).get(KEY)));
|
|
369
|
-
LOOKALIKES.forEach((prefix, i) => {
|
|
370
|
-
ensure(read[i] === i, `scope ${show(prefix)} read back ${show(read[i])}, another scope's`);
|
|
371
|
-
});
|
|
372
|
-
}
|
|
373
|
-
},
|
|
374
|
-
{
|
|
375
|
-
name: "nested scopes stay apart from look-alike prefixes",
|
|
376
|
-
run: async (store) => {
|
|
377
|
-
await scope_of(store, A).scope(B).set(KEY, "nested");
|
|
378
|
-
const read = await Promise.all(FLATTENED.map((prefix) => scope_of(store, prefix).get(KEY)));
|
|
379
|
-
FLATTENED.forEach((prefix, i) => {
|
|
380
|
-
ensure(is_miss(read[i]), `scope ${show(prefix)} read the value of scope 'b' in scope 'a'`);
|
|
381
|
-
});
|
|
382
|
-
const a = scope_of(store, A);
|
|
383
|
-
ensure(is_miss(await a.get(KEY)), "a nested scope's value showed up in its parent");
|
|
384
|
-
ensure(await a.scope(B).get(KEY) === "nested", "reopening a nested scope lost its value");
|
|
385
|
-
}
|
|
386
|
-
},
|
|
387
|
-
{
|
|
388
|
-
name: "clear empties a scope and nothing else",
|
|
389
|
-
run: async (store) => {
|
|
390
|
-
const a = scope_of(store, A);
|
|
391
|
-
await Promise.all([
|
|
392
|
-
store.set(KEY, "root"),
|
|
393
|
-
a.set(KEY, "a"),
|
|
394
|
-
a.scope(INNER).set(KEY, "inner"),
|
|
395
|
-
scope_of(store, B).set(KEY, "b")
|
|
396
|
-
]);
|
|
397
|
-
await a.clear();
|
|
398
|
-
ensure(is_miss(await a.get(KEY)), "a value survived clear");
|
|
399
|
-
ensure(is_miss(await a.scope(INNER).get(KEY)), "a nested scope's value survived clear");
|
|
400
|
-
ensure(await scope_of(store, B).get(KEY) === "b", "clear removed a sibling's value");
|
|
401
|
-
ensure(await store.get(KEY) === "root", "clear removed the parent's value");
|
|
402
|
-
await a.set(KEY, "again");
|
|
403
|
-
ensure(await a.get(KEY) === "again", "a cleared scope refused a new value");
|
|
404
|
-
}
|
|
405
|
-
},
|
|
406
|
-
{
|
|
407
|
-
name: "clear leaves look-alike scopes alone",
|
|
408
|
-
run: async (store) => {
|
|
409
|
-
await Promise.all(BESIDE_A.map((prefix, i) => scope_of(store, prefix).set(KEY, i)));
|
|
410
|
-
await scope_of(store, A).clear();
|
|
411
|
-
const read = await Promise.all(BESIDE_A.map((prefix) => scope_of(store, prefix).get(KEY)));
|
|
412
|
-
BESIDE_A.forEach((prefix, i) => {
|
|
413
|
-
ensure(read[i] === i, `clearing scope 'a' emptied scope ${show(prefix)}`);
|
|
414
|
-
});
|
|
415
|
-
}
|
|
416
|
-
},
|
|
417
|
-
{
|
|
418
|
-
name: "clearing an empty scope resolves",
|
|
419
|
-
run: async (store) => {
|
|
420
|
-
await scope_of(store, UNUSED).clear();
|
|
421
|
-
}
|
|
422
|
-
}
|
|
423
|
-
],
|
|
853
|
+
checks: SCOPE_CHECKS,
|
|
424
854
|
applies: (store) => store.scope !== void 0
|
|
425
855
|
},
|
|
426
856
|
{
|
|
427
|
-
checks:
|
|
428
|
-
{
|
|
429
|
-
name: "claim comes with release",
|
|
430
|
-
run: async (store) => {
|
|
431
|
-
claims_of(store);
|
|
432
|
-
}
|
|
433
|
-
},
|
|
434
|
-
{
|
|
435
|
-
name: "a free key can be claimed",
|
|
436
|
-
run: async (store) => {
|
|
437
|
-
ensure(await claims_of(store).claim(KEY, FIRST, HELD_MS), FREE_CLAIM_REFUSED);
|
|
438
|
-
}
|
|
439
|
-
},
|
|
440
|
-
{
|
|
441
|
-
name: "a held key refuses another owner",
|
|
442
|
-
run: async (store) => {
|
|
443
|
-
const claims = claims_of(store);
|
|
444
|
-
await claims.claim(KEY, FIRST, HELD_MS);
|
|
445
|
-
ensure(!await claims.claim(KEY, SECOND, HELD_MS), "a second owner claimed a key the first still holds");
|
|
446
|
-
}
|
|
447
|
-
},
|
|
448
|
-
{
|
|
449
|
-
name: "the owner can renew its claim",
|
|
450
|
-
run: async (store) => {
|
|
451
|
-
const claims = claims_of(store);
|
|
452
|
-
await claims.claim(KEY, FIRST, HELD_MS);
|
|
453
|
-
ensure(await claims.claim(KEY, FIRST, HELD_MS), RENEWAL_REFUSED);
|
|
454
|
-
}
|
|
455
|
-
},
|
|
456
|
-
{
|
|
457
|
-
name: "release lets another owner in",
|
|
458
|
-
run: async (store) => {
|
|
459
|
-
const claims = claims_of(store);
|
|
460
|
-
await claims.claim(KEY, FIRST, HELD_MS);
|
|
461
|
-
await claims.release(KEY, FIRST);
|
|
462
|
-
ensure(await claims.claim(KEY, SECOND, HELD_MS), "a released key refused the next owner");
|
|
463
|
-
}
|
|
464
|
-
},
|
|
465
|
-
{
|
|
466
|
-
name: "release by another owner changes nothing",
|
|
467
|
-
run: async (store) => {
|
|
468
|
-
const claims = claims_of(store);
|
|
469
|
-
await claims.claim(KEY, FIRST, HELD_MS);
|
|
470
|
-
await claims.release(KEY, SECOND);
|
|
471
|
-
ensure(!await claims.claim(KEY, SECOND, HELD_MS), "a release by a non-owner freed the owner's claim");
|
|
472
|
-
}
|
|
473
|
-
},
|
|
474
|
-
{
|
|
475
|
-
name: "releasing a key nobody holds resolves",
|
|
476
|
-
run: async (store) => {
|
|
477
|
-
await claims_of(store).release(UNCLAIMED, FIRST);
|
|
478
|
-
}
|
|
479
|
-
},
|
|
480
|
-
{
|
|
481
|
-
name: "claims and values stay apart",
|
|
482
|
-
run: async (store) => {
|
|
483
|
-
const claims = claims_of(store);
|
|
484
|
-
await store.set(KEY, "value");
|
|
485
|
-
ensure(await claims.claim(KEY, FIRST, HELD_MS), "a key that holds a value refused a claim");
|
|
486
|
-
ensure(await store.get(KEY) === "value", "claiming a key changed its value");
|
|
487
|
-
await store.delete(KEY);
|
|
488
|
-
ensure(!await claims.claim(KEY, SECOND, HELD_MS), "deleting a value released the claim on the same key");
|
|
489
|
-
await claims.claim(CLAIMED_ONLY, FIRST, HELD_MS);
|
|
490
|
-
ensure(is_miss(await store.get(CLAIMED_ONLY)), "claiming a key gave it a value");
|
|
491
|
-
}
|
|
492
|
-
},
|
|
493
|
-
{
|
|
494
|
-
name: "different keys are claimed apart",
|
|
495
|
-
run: async (store) => {
|
|
496
|
-
const claims = claims_of(store);
|
|
497
|
-
ensure(await claims.claim(A, FIRST, HELD_MS), FREE_CLAIM_REFUSED);
|
|
498
|
-
ensure(await claims.claim(B, SECOND, HELD_MS), "a claim on 'a' blocked a claim on 'b'");
|
|
499
|
-
}
|
|
500
|
-
},
|
|
501
|
-
{
|
|
502
|
-
name: "exactly one racing claimer wins a free key",
|
|
503
|
-
run: async (store) => {
|
|
504
|
-
const winners = await race_for(claims_of(store), KEY);
|
|
505
|
-
ensure(winners === 1, `${RACERS} owners raced for a free key and ${winners} won`);
|
|
506
|
-
}
|
|
507
|
-
},
|
|
508
|
-
{
|
|
509
|
-
name: "an expired claim passes to another owner",
|
|
510
|
-
run: async (store, env) => {
|
|
511
|
-
const claims = claims_of(store);
|
|
512
|
-
await claims.claim(KEY, FIRST, env.ttl_ms);
|
|
513
|
-
await sleep(env.ttl_ms * 2);
|
|
514
|
-
ensure(await claims.claim(KEY, SECOND, HELD_MS), `a claim was still held after its ${env.ttl_ms}ms ran out`);
|
|
515
|
-
ensure(!await claims.claim(KEY, FIRST, HELD_MS), "the first owner took back a claim that had passed to another");
|
|
516
|
-
}
|
|
517
|
-
},
|
|
518
|
-
{
|
|
519
|
-
name: "exactly one racing claimer takes an expired claim",
|
|
520
|
-
run: async (store, env) => {
|
|
521
|
-
const claims = claims_of(store);
|
|
522
|
-
await claims.claim(KEY, FIRST, env.ttl_ms);
|
|
523
|
-
await sleep(env.ttl_ms * 2);
|
|
524
|
-
const winners = await race_for(claims, KEY);
|
|
525
|
-
ensure(winners === 1, `${RACERS} owners raced for an expired claim and ${winners} won`);
|
|
526
|
-
}
|
|
527
|
-
},
|
|
528
|
-
{
|
|
529
|
-
name: "renewing restarts the clock",
|
|
530
|
-
run: async (store, env) => {
|
|
531
|
-
const claims = claims_of(store);
|
|
532
|
-
const started = Date.now();
|
|
533
|
-
await claims.claim(KEY, FIRST, env.ttl_ms);
|
|
534
|
-
await sleep(env.ttl_ms / 2);
|
|
535
|
-
const renewed = Date.now();
|
|
536
|
-
ensure(await claims.claim(KEY, FIRST, env.ttl_ms), RENEWAL_REFUSED);
|
|
537
|
-
await sleep(Math.max(0, started + env.ttl_ms * 1.2 - Date.now()));
|
|
538
|
-
const second = await claims.claim(KEY, SECOND, HELD_MS);
|
|
539
|
-
if (Date.now() >= renewed + env.ttl_ms) return;
|
|
540
|
-
ensure(!second, "a renewed claim expired on its original schedule");
|
|
541
|
-
}
|
|
542
|
-
}
|
|
543
|
-
],
|
|
857
|
+
checks: CLAIM_CHECKS,
|
|
544
858
|
applies: (store) => store.claim !== void 0 || store.release !== void 0
|
|
545
859
|
},
|
|
546
860
|
{
|
|
547
|
-
checks:
|
|
548
|
-
{
|
|
549
|
-
name: "scopes keep the claim capability",
|
|
550
|
-
run: async (store) => {
|
|
551
|
-
ensure(await claims_of(scope_of(store, A)).claim(KEY, FIRST, HELD_MS), FRESH_SCOPE_CLAIM_REFUSED);
|
|
552
|
-
}
|
|
553
|
-
},
|
|
554
|
-
{
|
|
555
|
-
name: "claims in different scopes stay apart",
|
|
556
|
-
run: async (store) => {
|
|
557
|
-
const first = await claims_of(scope_of(store, A)).claim(KEY, FIRST, HELD_MS);
|
|
558
|
-
const second = await claims_of(scope_of(store, B)).claim(KEY, SECOND, HELD_MS);
|
|
559
|
-
const third = await claims_of(store).claim(KEY, THIRD, HELD_MS);
|
|
560
|
-
ensure(first, FRESH_SCOPE_CLAIM_REFUSED);
|
|
561
|
-
ensure(second, "scope 'b' couldn't claim a key held in scope 'a'");
|
|
562
|
-
ensure(third, "the parent couldn't claim a key held in a scope");
|
|
563
|
-
}
|
|
564
|
-
},
|
|
565
|
-
{
|
|
566
|
-
name: "clear drops the claims under a scope",
|
|
567
|
-
run: async (store) => {
|
|
568
|
-
const a = scope_of(store, A);
|
|
569
|
-
ensure(await claims_of(a).claim(KEY, FIRST, HELD_MS), FRESH_SCOPE_CLAIM_REFUSED);
|
|
570
|
-
await a.clear();
|
|
571
|
-
ensure(await claims_of(a).claim(KEY, SECOND, HELD_MS), "a claim survived clear");
|
|
572
|
-
}
|
|
573
|
-
}
|
|
574
|
-
],
|
|
861
|
+
checks: SCOPED_CLAIM_CHECKS,
|
|
575
862
|
applies: (store) => store.scope !== void 0 && store.claim !== void 0
|
|
863
|
+
},
|
|
864
|
+
{
|
|
865
|
+
checks: CAS_CHECKS,
|
|
866
|
+
applies: has_cas
|
|
867
|
+
},
|
|
868
|
+
{
|
|
869
|
+
checks: [CAS_DAMAGE_CHECK],
|
|
870
|
+
applies: (store, options) => has_cas(store) && options.corrupt !== void 0
|
|
871
|
+
},
|
|
872
|
+
{
|
|
873
|
+
checks: SCOPED_CAS_CHECKS,
|
|
874
|
+
applies: (store) => store.scope !== void 0 && has_cas(store)
|
|
576
875
|
}
|
|
577
876
|
];
|
|
578
877
|
/**
|
|
@@ -592,8 +891,9 @@ async function run_check(check, make_store, env) {
|
|
|
592
891
|
*
|
|
593
892
|
* The capabilities are read off the first store `make_store` returns: scope
|
|
594
893
|
* checks run when it has `scope`, claim checks when it has `claim` or
|
|
595
|
-
* `release`, and
|
|
596
|
-
*
|
|
894
|
+
* `release`, compare-and-set checks when it has `get_versioned` or `set_if`,
|
|
895
|
+
* and the damage checks when `options.corrupt` is given. Every other check
|
|
896
|
+
* lands in `skipped`. Checks run one at a time, because some wait
|
|
597
897
|
* on claim expiry and a store's backing service may be shared between the
|
|
598
898
|
* stores `make_store` hands out.
|
|
599
899
|
*/
|