The best way to control Claude Code, Codex and more from any computer or phone
| 1 | import * as NodeFileSystem from "@effect/platform-node/NodeFileSystem" |
| 2 | import * as NodePath from "@effect/platform-node/NodePath" |
| 3 | import { assert, describe, it } from "@effect/vitest" |
| 4 | import { clearPrefixSuite } from "effect-test/persistence/KeyValueStoreTest" |
| 5 | import * as Effect from "effect/Effect" |
| 6 | import * as FileSystem from "effect/FileSystem" |
| 7 | import * as Layer from "effect/Layer" |
| 8 | import * as KeyValueStore from "effect/persistence/KeyValueStore" |
| 9 | |
| 10 | const platformLayer = Layer.merge(NodeFileSystem.layer, NodePath.layer) |
| 11 | |
| 12 | describe("KeyValueStore / layerFileSystem", () => { |
| 13 | clearPrefixSuite( |
| 14 | "file system", |
| 15 | Layer.unwrap(Effect.gen(function*() { |
| 16 | const fs = yield* FileSystem.FileSystem |
| 17 | const directory = yield* fs.makeTempDirectoryScoped() |
| 18 | return KeyValueStore.layerFileSystem(directory).pipe(Layer.provide(platformLayer)) |
| 19 | })).pipe(Layer.provide(NodeFileSystem.layer)) |
| 20 | ) |
| 21 | |
| 22 | it.effect("rejects invalid keys without modifying the file system", () => |
| 23 | Effect.gen(function*() { |
| 24 | const fs = yield* FileSystem.FileSystem |
| 25 | const root = yield* fs.makeTempDirectoryScoped() |
| 26 | const directory = `${root}/store` |
| 27 | const sibling = `${root}/sibling.txt` |
| 28 | yield* fs.makeDirectory(directory) |
| 29 | yield* fs.writeFileString(sibling, "sibling") |
| 30 | |
| 31 | yield* Effect.gen(function*() { |
| 32 | const store = yield* KeyValueStore.KeyValueStore |
| 33 | |
| 34 | for (const key of ["", ".", ".."]) { |
| 35 | const operations = [ |
| 36 | ["get", Effect.asVoid(store.get(key))], |
| 37 | ["getUint8Array", Effect.asVoid(store.getUint8Array(key))], |
| 38 | ["set", Effect.asVoid(store.set(key, "value"))], |
| 39 | ["remove", Effect.asVoid(store.remove(key))], |
| 40 | ["has", Effect.asVoid(store.has(key))] |
| 41 | ] as const |
| 42 | |
| 43 | for (const [method, operation] of operations) { |
| 44 | const error = yield* Effect.flip(operation) |
| 45 | assert.instanceOf(error, KeyValueStore.KeyValueStoreError) |
| 46 | assert.strictEqual(error.method, method) |
| 47 | assert.strictEqual(error.key, key) |
| 48 | } |
| 49 | } |
| 50 | }).pipe( |
| 51 | Effect.provide(KeyValueStore.layerFileSystem(directory).pipe(Layer.provide(platformLayer))) |
| 52 | ) |
| 53 | |
| 54 | assert.isTrue(yield* fs.exists(directory)) |
| 55 | assert.deepStrictEqual(yield* fs.readDirectory(directory), []) |
| 56 | assert.strictEqual(yield* fs.readFileString(sibling), "sibling") |
| 57 | }).pipe( |
| 58 | Effect.provide(NodeFileSystem.layer) |
| 59 | )) |
| 60 | |
| 61 | it.effect("keys decodes file names", () => |
| 62 | Effect.gen(function*() { |
| 63 | const fs = yield* FileSystem.FileSystem |
| 64 | const directory = yield* fs.makeTempDirectoryScoped() |
| 65 | |
| 66 | yield* Effect.gen(function*() { |
| 67 | const store = yield* KeyValueStore.KeyValueStore |
| 68 | yield* store.set("/foo/bar", "1") |
| 69 | yield* store.set("a b%", "2") |
| 70 | |
| 71 | assert.deepStrictEqual([...(yield* store.keys)].sort(), ["/foo/bar", "a b%"]) |
| 72 | }).pipe( |
| 73 | Effect.provide(KeyValueStore.layerFileSystem(directory).pipe(Layer.provide(platformLayer))) |
| 74 | ) |
| 75 | }).pipe( |
| 76 | Effect.provide(NodeFileSystem.layer) |
| 77 | )) |
| 78 | |
| 79 | it.effect("remove succeeds for a missing key", () => |
| 80 | Effect.gen(function*() { |
| 81 | const fs = yield* FileSystem.FileSystem |
| 82 | const directory = yield* fs.makeTempDirectoryScoped() |
| 83 | |
| 84 | yield* KeyValueStore.KeyValueStore.use((store) => store.remove("missing")).pipe( |
| 85 | Effect.provide(KeyValueStore.layerFileSystem(directory).pipe(Layer.provide(platformLayer))) |
| 86 | ) |
| 87 | }).pipe( |
| 88 | Effect.provide(NodeFileSystem.layer) |
| 89 | )) |
| 90 | }) |