summaryrefslogtreecommitdiff
path: root/cli
diff options
context:
space:
mode:
Diffstat (limited to 'cli')
-rw-r--r--cli/build.rs2
-rw-r--r--cli/tests/unit/kv_test.ts351
2 files changed, 169 insertions, 184 deletions
diff --git a/cli/build.rs b/cli/build.rs
index f01c006be..e6b9dc0a4 100644
--- a/cli/build.rs
+++ b/cli/build.rs
@@ -381,7 +381,7 @@ fn create_cli_snapshot(snapshot_path: PathBuf) -> CreateSnapshotOutput {
deno_net::deno_net::init_ops::<PermissionsContainer>(None, None),
deno_tls::deno_tls::init_ops(),
deno_kv::deno_kv::init_ops(SqliteDbHandler::<PermissionsContainer>::new(
- None,
+ None, None,
)),
deno_napi::deno_napi::init_ops::<PermissionsContainer>(),
deno_http::deno_http::init_ops::<DefaultHttpPropertyExtractor>(),
diff --git a/cli/tests/unit/kv_test.ts b/cli/tests/unit/kv_test.ts
index 7cb8ebccf..4e3ce5385 100644
--- a/cli/tests/unit/kv_test.ts
+++ b/cli/tests/unit/kv_test.ts
@@ -55,9 +55,7 @@ function dbTest(name: string, fn: (db: Deno.Kv) => Promise<void> | void) {
// https://github.com/denoland/deno/issues/18363
ignore: Deno.build.os === "darwin" && isCI,
async fn() {
- const db: Deno.Kv = await Deno.openKv(
- ":memory:",
- );
+ const db: Deno.Kv = await Deno.openKv(":memory:");
try {
await fn(db);
} finally {
@@ -73,14 +71,14 @@ function queueTest(name: string, fn: (db: Deno.Kv) => Promise<void>) {
// https://github.com/denoland/deno/issues/18363
ignore: Deno.build.os === "darwin" && isCI,
async fn() {
- const db: Deno.Kv = await Deno.openKv(
- ":memory:",
- );
+ const db: Deno.Kv = await Deno.openKv(":memory:");
await fn(db);
},
});
}
+const ZERO_VERSIONSTAMP = "00000000000000000000";
+
dbTest("basic read-write-delete and versionstamps", async (db) => {
const result1 = await db.get(["a"]);
assertEquals(result1.key, ["a"]);
@@ -89,17 +87,19 @@ dbTest("basic read-write-delete and versionstamps", async (db) => {
const setRes = await db.set(["a"], "b");
assert(setRes.ok);
- assertEquals(setRes.versionstamp, "00000000000000010000");
+ assert(setRes.versionstamp > ZERO_VERSIONSTAMP);
const result2 = await db.get(["a"]);
assertEquals(result2.key, ["a"]);
assertEquals(result2.value, "b");
- assertEquals(result2.versionstamp, "00000000000000010000");
+ assertEquals(result2.versionstamp, setRes.versionstamp);
- await db.set(["a"], "c");
+ const setRes2 = await db.set(["a"], "c");
+ assert(setRes2.ok);
+ assert(setRes2.versionstamp > setRes.versionstamp);
const result3 = await db.get(["a"]);
assertEquals(result3.key, ["a"]);
assertEquals(result3.value, "c");
- assertEquals(result3.versionstamp, "00000000000000020000");
+ assertEquals(result3.versionstamp, setRes2.versionstamp);
await db.delete(["a"]);
const result4 = await db.get(["a"]);
@@ -230,17 +230,18 @@ dbTest("compare and mutate", async (db) => {
await db.set(["t"], "1");
const currentValue = await db.get(["t"]);
- assertEquals(currentValue.versionstamp, "00000000000000010000");
+ assert(currentValue.versionstamp);
+ assert(currentValue.versionstamp > ZERO_VERSIONSTAMP);
let res = await db.atomic()
.check({ key: ["t"], versionstamp: currentValue.versionstamp })
.set(currentValue.key, "2")
.commit();
assert(res.ok);
- assertEquals(res.versionstamp, "00000000000000020000");
+ assert(res.versionstamp > currentValue.versionstamp);
const newValue = await db.get(["t"]);
- assertEquals(newValue.versionstamp, "00000000000000020000");
+ assertEquals(newValue.versionstamp, res.versionstamp);
assertEquals(newValue.value, "2");
res = await db.atomic()
@@ -250,7 +251,7 @@ dbTest("compare and mutate", async (db) => {
assert(!res.ok);
const newValue2 = await db.get(["t"]);
- assertEquals(newValue2.versionstamp, "00000000000000020000");
+ assertEquals(newValue2.versionstamp, newValue.versionstamp);
assertEquals(newValue2.value, "2");
});
@@ -260,9 +261,10 @@ dbTest("compare and mutate not exists", async (db) => {
.set(["t"], "1")
.commit();
assert(res.ok);
+ assert(res.versionstamp > ZERO_VERSIONSTAMP);
const newValue = await db.get(["t"]);
- assertEquals(newValue.versionstamp, "00000000000000010000");
+ assertEquals(newValue.versionstamp, res.versionstamp);
assertEquals(newValue.value, "1");
res = await db.atomic()
@@ -303,13 +305,17 @@ dbTest("atomic mutation helper (max)", async (db) => {
});
dbTest("compare multiple and mutate", async (db) => {
- await db.set(["t1"], "1");
- await db.set(["t2"], "2");
+ const setRes1 = await db.set(["t1"], "1");
+ const setRes2 = await db.set(["t2"], "2");
+ assert(setRes1.ok);
+ assert(setRes1.versionstamp > ZERO_VERSIONSTAMP);
+ assert(setRes2.ok);
+ assert(setRes2.versionstamp > ZERO_VERSIONSTAMP);
const currentValue1 = await db.get(["t1"]);
- assertEquals(currentValue1.versionstamp, "00000000000000010000");
+ assertEquals(currentValue1.versionstamp, setRes1.versionstamp);
const currentValue2 = await db.get(["t2"]);
- assertEquals(currentValue2.versionstamp, "00000000000000020000");
+ assertEquals(currentValue2.versionstamp, setRes2.versionstamp);
const res = await db.atomic()
.check({ key: ["t1"], versionstamp: currentValue1.versionstamp })
@@ -318,12 +324,13 @@ dbTest("compare multiple and mutate", async (db) => {
.set(currentValue2.key, "4")
.commit();
assert(res.ok);
+ assert(res.versionstamp > setRes2.versionstamp);
const newValue1 = await db.get(["t1"]);
- assertEquals(newValue1.versionstamp, "00000000000000030000");
+ assertEquals(newValue1.versionstamp, res.versionstamp);
assertEquals(newValue1.value, "3");
const newValue2 = await db.get(["t2"]);
- assertEquals(newValue2.versionstamp, "00000000000000030000");
+ assertEquals(newValue2.versionstamp, res.versionstamp);
assertEquals(newValue2.value, "4");
// just one of the two checks failed
@@ -336,10 +343,10 @@ dbTest("compare multiple and mutate", async (db) => {
assert(!res2.ok);
const newValue3 = await db.get(["t1"]);
- assertEquals(newValue3.versionstamp, "00000000000000030000");
+ assertEquals(newValue3.versionstamp, res.versionstamp);
assertEquals(newValue3.value, "3");
const newValue4 = await db.get(["t2"]);
- assertEquals(newValue4.versionstamp, "00000000000000030000");
+ assertEquals(newValue4.versionstamp, res.versionstamp);
assertEquals(newValue4.value, "4");
});
@@ -635,8 +642,8 @@ async function collect<T>(
return entries;
}
-async function setupData(db: Deno.Kv) {
- await db.atomic()
+async function setupData(db: Deno.Kv): Promise<string> {
+ const res = await db.atomic()
.set(["a"], -1)
.set(["a", "a"], 0)
.set(["a", "b"], 1)
@@ -646,27 +653,29 @@ async function setupData(db: Deno.Kv) {
.set(["b"], 99)
.set(["b", "a"], 100)
.commit();
+ assert(res.ok);
+ return res.versionstamp;
}
dbTest("get many", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await db.getMany([["b", "a"], ["a"], ["c"]]);
assertEquals(entries, [
- { key: ["b", "a"], value: 100, versionstamp: "00000000000000010000" },
- { key: ["a"], value: -1, versionstamp: "00000000000000010000" },
+ { key: ["b", "a"], value: 100, versionstamp },
+ { key: ["a"], value: -1, versionstamp },
{ key: ["c"], value: null, versionstamp: null },
]);
});
dbTest("list prefix", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(db.list({ prefix: ["a"] }));
assertEquals(entries, [
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
+ { key: ["a", "a"], value: 0, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "e"], value: 4, versionstamp },
]);
});
@@ -680,12 +689,12 @@ dbTest("list prefix empty", async (db) => {
});
dbTest("list prefix with start", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(db.list({ prefix: ["a"], start: ["a", "c"] }));
assertEquals(entries, [
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "e"], value: 4, versionstamp },
]);
});
@@ -696,11 +705,11 @@ dbTest("list prefix with start empty", async (db) => {
});
dbTest("list prefix with end", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(db.list({ prefix: ["a"], end: ["a", "c"] }));
assertEquals(entries, [
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
+ { key: ["a", "a"], value: 0, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
]);
});
@@ -711,35 +720,34 @@ dbTest("list prefix with end empty", async (db) => {
});
dbTest("list prefix with empty prefix", async (db) => {
- await db.set(["a"], 1);
+ const res = await db.set(["a"], 1);
const entries = await collect(db.list({ prefix: [] }));
assertEquals(entries, [
- { key: ["a"], value: 1, versionstamp: "00000000000000010000" },
+ { key: ["a"], value: 1, versionstamp: res.versionstamp },
]);
});
dbTest("list prefix reverse", async (db) => {
- await setupData(db);
-
+ const versionstamp = await setupData(db);
const entries = await collect(db.list({ prefix: ["a"] }, { reverse: true }));
assertEquals(entries, [
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
+ { key: ["a", "e"], value: 4, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "a"], value: 0, versionstamp },
]);
});
dbTest("list prefix reverse with start", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ prefix: ["a"], start: ["a", "c"] }, { reverse: true }),
);
assertEquals(entries, [
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
+ { key: ["a", "e"], value: 4, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
]);
});
@@ -752,13 +760,13 @@ dbTest("list prefix reverse with start empty", async (db) => {
});
dbTest("list prefix reverse with end", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ prefix: ["a"], end: ["a", "c"] }, { reverse: true }),
);
assertEquals(entries, [
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "a"], value: 0, versionstamp },
]);
});
@@ -771,83 +779,82 @@ dbTest("list prefix reverse with end empty", async (db) => {
});
dbTest("list prefix limit", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(db.list({ prefix: ["a"] }, { limit: 2 }));
assertEquals(entries, [
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
+ { key: ["a", "a"], value: 0, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
]);
});
dbTest("list prefix limit reverse", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ prefix: ["a"] }, { limit: 2, reverse: true }),
);
assertEquals(entries, [
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
+ { key: ["a", "e"], value: 4, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
]);
});
dbTest("list prefix with small batch size", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(db.list({ prefix: ["a"] }, { batchSize: 2 }));
assertEquals(entries, [
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
+ { key: ["a", "a"], value: 0, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "e"], value: 4, versionstamp },
]);
});
dbTest("list prefix with small batch size reverse", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ prefix: ["a"] }, { batchSize: 2, reverse: true }),
);
assertEquals(entries, [
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
+ { key: ["a", "e"], value: 4, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "a"], value: 0, versionstamp },
]);
});
dbTest("list prefix with small batch size and limit", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ prefix: ["a"] }, { batchSize: 2, limit: 3 }),
);
assertEquals(entries, [
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
+ { key: ["a", "a"], value: 0, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
]);
});
dbTest("list prefix with small batch size and limit reverse", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ prefix: ["a"] }, { batchSize: 2, limit: 3, reverse: true }),
);
assertEquals(entries, [
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
+ { key: ["a", "e"], value: 4, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
]);
});
dbTest("list prefix with manual cursor", async (db) => {
- await setupData(db);
-
+ const versionstamp = await setupData(db);
const iterator = db.list({ prefix: ["a"] }, { limit: 2 });
const values = await collect(iterator);
assertEquals(values, [
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
+ { key: ["a", "a"], value: 0, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
]);
const cursor = iterator.cursor;
@@ -856,20 +863,20 @@ dbTest("list prefix with manual cursor", async (db) => {
const iterator2 = db.list({ prefix: ["a"] }, { cursor });
const values2 = await collect(iterator2);
assertEquals(values2, [
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "e"], value: 4, versionstamp },
]);
});
dbTest("list prefix with manual cursor reverse", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const iterator = db.list({ prefix: ["a"] }, { limit: 2, reverse: true });
const values = await collect(iterator);
assertEquals(values, [
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
+ { key: ["a", "e"], value: 4, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
]);
const cursor = iterator.cursor;
@@ -878,57 +885,57 @@ dbTest("list prefix with manual cursor reverse", async (db) => {
const iterator2 = db.list({ prefix: ["a"] }, { cursor, reverse: true });
const values2 = await collect(iterator2);
assertEquals(values2, [
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "a"], value: 0, versionstamp },
]);
});
dbTest("list range", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ start: ["a", "a"], end: ["a", "z"] }),
);
assertEquals(entries, [
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
+ { key: ["a", "a"], value: 0, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "e"], value: 4, versionstamp },
]);
});
dbTest("list range reverse", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ start: ["a", "a"], end: ["a", "z"] }, { reverse: true }),
);
assertEquals(entries, [
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
+ { key: ["a", "e"], value: 4, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "a"], value: 0, versionstamp },
]);
});
dbTest("list range with limit", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ start: ["a", "a"], end: ["a", "z"] }, { limit: 3 }),
);
assertEquals(entries, [
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
+ { key: ["a", "a"], value: 0, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
]);
});
dbTest("list range with limit reverse", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ start: ["a", "a"], end: ["a", "z"] }, {
@@ -937,46 +944,46 @@ dbTest("list range with limit reverse", async (db) => {
}),
);
assertEquals(entries, [
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
+ { key: ["a", "e"], value: 4, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
]);
});
dbTest("list range nesting", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(db.list({ start: ["a"], end: ["a", "d"] }));
assertEquals(entries, [
- { key: ["a"], value: -1, versionstamp: "00000000000000010000" },
- { key: ["a", "a"], value: 0, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
+ { key: ["a"], value: -1, versionstamp },
+ { key: ["a", "a"], value: 0, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
]);
});
dbTest("list range short", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const entries = await collect(
db.list({ start: ["a", "b"], end: ["a", "d"] }),
);
assertEquals(entries, [
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
]);
});
dbTest("list range with manual cursor", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const iterator = db.list({ start: ["a", "b"], end: ["a", "z"] }, {
limit: 2,
});
const entries = await collect(iterator);
assertEquals(entries, [
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
+ { key: ["a", "b"], value: 1, versionstamp },
+ { key: ["a", "c"], value: 2, versionstamp },
]);
const cursor = iterator.cursor;
@@ -985,13 +992,13 @@ dbTest("list range with manual cursor", async (db) => {
});
const entries2 = await collect(iterator2);
assertEquals(entries2, [
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
+ { key: ["a", "d"], value: 3, versionstamp },
+ { key: ["a", "e"], value: 4, versionstamp },
]);
});
dbTest("list range with manual cursor reverse", async (db) => {
- await setupData(db);
+ const versionstamp = await setupData(db);
const iterator = db.list({ start: ["a", "b"], end: ["a", "z"] }, {
limit: 2,
@@ -999,8 +1006,8 @@ dbTest("list range with manual cursor reverse", async (db) => {
});
const entries = await collect(iterator);
assertEquals(entries, [
- { key: ["a", "e"], value: 4, versionstamp: "00000000000000010000" },
- { key: ["a", "d"], value: 3, versionstamp: "00000000000000010000" },
+ { key: ["a", "e"], value: 4, versionstamp },
+ { key: ["a", "d"], value: 3, versionstamp },
]);
const cursor = iterator.cursor;
@@ -1010,8 +1017,8 @@ dbTest("list range with manual cursor reverse", async (db) => {
});
const entries2 = await collect(iterator2);
assertEquals(entries2, [
- { key: ["a", "c"], value: 2, versionstamp: "00000000000000010000" },
- { key: ["a", "b"], value: 1, versionstamp: "00000000000000010000" },
+ { key: ["a", "c"], value: 2, versionstamp },
+ { key: ["a", "b"], value: 1, versionstamp },
]);
});
@@ -1110,12 +1117,12 @@ dbTest("key size limit", async (db) => {
const lastValidKey = new Uint8Array(2046).fill(1);
const firstInvalidKey = new Uint8Array(2047).fill(1);
- await db.set([lastValidKey], 1);
+ const res = await db.set([lastValidKey], 1);
assertEquals(await db.get([lastValidKey]), {
key: [lastValidKey],
value: 1,
- versionstamp: "00000000000000010000",
+ versionstamp: res.versionstamp,
});
await assertRejects(
@@ -1135,11 +1142,11 @@ dbTest("value size limit", async (db) => {
const lastValidValue = new Uint8Array(65536);
const firstInvalidValue = new Uint8Array(65537);
- await db.set(["a"], lastValidValue);
+ const res = await db.set(["a"], lastValidValue);
assertEquals(await db.get(["a"]), {
key: ["a"],
value: lastValidValue,
- versionstamp: "00000000000000010000",
+ versionstamp: res.versionstamp,
});
await assertRejects(
@@ -1415,21 +1422,17 @@ for (const { name, value } of VALUE_CASES) {
queueTest(`listenQueue and enqueue ${name}`, async (db) => {
const numEnqueues = 10;
let count = 0;
- const promises: Deferred<void>[] = [];
- const dequeuedMessages: unknown[] = [];
+ const promises: Deferred<unknown>[] = [];
const listeners: Promise<void>[] = [];
- listeners.push(db.listenQueue((msg) => {
- dequeuedMessages.push(msg);
- promises[count++].resolve();
+ listeners.push(db.listenQueue((msg: unknown) => {
+ promises[count++].resolve(msg);
}));
try {
for (let i = 0; i < numEnqueues; i++) {
promises.push(deferred());
await db.enqueue(value);
}
- for (let i = 0; i < numEnqueues; i++) {
- await promises[i];
- }
+ const dequeuedMessages = await Promise.all(promises);
for (let i = 0; i < numEnqueues; i++) {
assertEquals(dequeuedMessages[i], value);
}
@@ -1445,7 +1448,7 @@ for (const { name, value } of VALUE_CASES) {
queueTest("queue mixed types", async (db) => {
let promise: Deferred<void>;
let dequeuedMessage: unknown = null;
- const listener = db.listenQueue((msg) => {
+ const listener = db.listenQueue((msg: unknown) => {
dequeuedMessage = msg;
promise.resolve();
});
@@ -2066,25 +2069,16 @@ Deno.test({
const db = await Deno.openKv(
"http://localhost:4545/kv_remote_authorize_invalid_format",
);
- let ok = false;
- try {
- await db.set(["some-key"], 1);
- } catch (e) {
- if (
- e.name === "TypeError" &&
- e.message.startsWith("Metadata error: Failed to decode metadata: ")
- ) {
- ok = true;
- } else {
- throw e;
- }
- } finally {
- db.close();
- }
- if (!ok) {
- throw new Error("did not get expected error");
- }
+ await assertRejects(
+ async () => {
+ await db.set(["some-key"], 1);
+ },
+ Error,
+ "Failed to parse metadata: ",
+ );
+
+ db.close();
},
});
@@ -2094,24 +2088,15 @@ Deno.test({
const db = await Deno.openKv(
"http://localhost:4545/kv_remote_authorize_invalid_version",
);
- let ok = false;
- try {
- await db.set(["some-key"], 1);
- } catch (e) {
- if (
- e.name === "TypeError" &&
- e.message === "Metadata error: Unsupported metadata version: 2"
- ) {
- ok = true;
- } else {
- throw e;
- }
- } finally {
- db.close();
- }
- if (!ok) {
- throw new Error("did not get expected error");
- }
+ await assertRejects(
+ async () => {
+ await db.set(["some-key"], 1);
+ },
+ Error,
+ "Failed to parse metadata: unsupported metadata version: 1000",
+ );
+
+ db.close();
},
});
generated by cgit v1.2.3 (git 2.25.1) at 2025-06-27 07:42:05 +0000