sailfork / t3code-github / infra/ task-cache/ src/ WriterRegistry.test.ts

import * as NodeCrypto from "@effect/platform-node/NodeCrypto";
import * as NodeServices from "@effect/platform-node/NodeServices";
import { expect, it } from "@effect/vitest";
import * as Config from "effect/Config";
import * as ConfigProvider from "effect/ConfigProvider";
import * as Effect from "effect/Effect";
import * as Exit from "effect/Exit";
import * as Layer from "effect/Layer";
import * as FileSystem from "effect/FileSystem";
import * as PlatformError from "effect/PlatformError";
import * as Redacted from "effect/Redacted";
import * as ChildProcess from "effect/process/ChildProcess";
import * as ChildProcessSpawner from "effect/process/ChildProcessSpawner";
import * as WriterRegistry from "./WriterRegistry.ts";
import { WriterSecrets } from "./deploymentConfig.ts";

const readKeys = Config.Redacted("DEVELOPER_KEYS").pipe(Effect.provide(WriterSecrets));

it.effect("loads the private writer registry as deployment configuration", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const home = yield* fs.makeTempDirectoryScoped();
    yield* fs.makeDirectory(`${home}/.config/t3-task-cache`, { recursive: true });
    yield* fs.writeFileString(`${home}/.config/t3-task-cache/writers.json`, '{"maria":"digest"}');
    yield* fs.writeFileString(
      `${home}/.config/t3-task-cache/readers.json`,
      '{"ci-reader":"digest"}',
    );
    const keys = yield* readKeys.pipe(
      Effect.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({ HOME: home }))),
    );
    expect(JSON.parse(Redacted.value(keys))).toEqual({ maria: "digest" });
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("uses explicit deployment credentials without requiring a local registry", () =>
  Effect.gen(function* () {
    const keys = yield* readKeys.pipe(
      Effect.provide(
        ConfigProvider.layer(
          ConfigProvider.fromUnknown({ DEVELOPER_KEYS: '{"theo":"digest"}', READER_KEYS: "{}" }),
        ),
      ),
    );
    expect(JSON.parse(Redacted.value(keys))).toEqual({ theo: "digest" });
  }).pipe(Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("fails instead of deploying an empty registry when credentials are missing", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const home = yield* fs.makeTempDirectoryScoped();
    const result = yield* readKeys.pipe(
      Effect.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({ HOME: home }))),
      Effect.exit,
    );
    expect(Exit.isFailure(result)).toBe(true);
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.live("rejects reserved writer names without modifying credential stores", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const spawner = yield* ChildProcessSpawner.ChildProcessSpawner;
    const home = yield* fs.makeTempDirectoryScoped();
    const state = `${home}/.config/t3-task-cache`;
    yield* fs.makeDirectory(state, { recursive: true });
    const writers = '{"maria":"digest"}';
    const credentials = '{"https://cache.example":{"name":"maria","token":"secret"}}';
    yield* fs.writeFileString(`${state}/writers.json`, writers);
    yield* fs.writeFileString(`${state}/credentials.json`, credentials);
    for (const name of ["writers", "credentials", "readers", "ci-reader"]) {
      const code = yield* spawner.exitCode(
        ChildProcess.make(
          "node",
          [`${import.meta.dirname}/../scripts/manage.ts`, "add-writer", name],
          {
            env: { HOME: home },
            extendEnv: true,
            stdout: "ignore",
            stderr: "ignore",
          },
        ),
      );
      expect(code).not.toBe(0);
      expect(yield* fs.readFileString(`${state}/writers.json`)).toBe(writers);
      expect(yield* fs.readFileString(`${state}/credentials.json`)).toBe(credentials);
    }
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("writes credentials for the supplied deployed worker endpoint", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const home = yield* fs.makeTempDirectoryScoped();
    const endpoint = "https://preview-cache.example/projects/t3code";
    const file = yield* WriterRegistry.WriterRegistry.pipe(
      Effect.flatMap((registry) => registry.update("maria", false, endpoint, true)),
      Effect.provide(
        WriterRegistry.layer.pipe(
          Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({ HOME: home }))),
        ),
      ),
    );
    expect(file).toBe(`${home}/.config/t3-task-cache/maria.json`);
    if (!file) return yield* Effect.die("Expected a credential file");
    const credential = JSON.parse(yield* fs.readFileString(file));
    expect(credential.endpoint).toBe(endpoint);
    expect(credential.name).toBe("maria");
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("refuses a concurrent registry update without changing committed credentials", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const home = yield* fs.makeTempDirectoryScoped();
    const state = `${home}/.config/t3-task-cache`;
    yield* fs.makeDirectory(`${state}/writers.lock`, { recursive: true });
    yield* fs.writeFileString(`${state}/writers.json`, '{"maria":"digest"}');
    const result = yield* WriterRegistry.WriterRegistry.pipe(
      Effect.flatMap((registry) => registry.update("theo", false, "https://cache.example")),
      Effect.provide(
        WriterRegistry.layer.pipe(
          Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({ HOME: home }))),
        ),
      ),
      Effect.exit,
    );
    expect(Exit.isFailure(result)).toBe(true);
    expect(yield* fs.readFileString(`${state}/writers.json`)).toBe('{"maria":"digest"}');
    expect(yield* fs.exists(`${state}/theo.json`)).toBe(false);
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("keeps the committed registry intact if a replacement write fails", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const home = yield* fs.makeTempDirectoryScoped();
    const state = `${home}/.config/t3-task-cache`;
    yield* fs.makeDirectory(state, { recursive: true });
    const original = '{"maria":"digest"}';
    yield* fs.writeFileString(`${state}/writers.json`, original);
    const result = yield* WriterRegistry.WriterRegistry.pipe(
      Effect.flatMap((registry) => registry.update("theo", false, "https://cache.example")),
      Effect.provide(
        WriterRegistry.layer.pipe(
          Layer.provide([
            ConfigProvider.layer(ConfigProvider.fromUnknown({ HOME: home })),
            Layer.succeed(FileSystem.FileSystem, {
              ...fs,
              writeFileString: (path) =>
                fs
                  .writeFileString(path, "partial")
                  .pipe(Effect.andThen(Effect.die("disk write failed"))),
            }),
          ]),
        ),
      ),
      Effect.exit,
    );
    expect(Exit.isFailure(result)).toBe(true);
    expect(yield* fs.readFileString(`${state}/writers.json`)).toBe(original);
    expect(yield* fs.exists(`${state}/writers.lock`)).toBe(false);
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("preserves filesystem errors when acquiring the registry lock", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const home = yield* fs.makeTempDirectoryScoped();
    const denied = PlatformError.systemError({
      _tag: "PermissionDenied",
      module: "FileSystem",
      method: "makeDirectory",
    });
    const error = yield* WriterRegistry.WriterRegistry.pipe(
      Effect.flatMap((registry) => registry.update("theo", false, "https://cache.example")),
      Effect.provide(
        WriterRegistry.layer.pipe(
          Layer.provide([
            ConfigProvider.layer(ConfigProvider.fromUnknown({ HOME: home })),
            Layer.succeed(FileSystem.FileSystem, {
              ...fs,
              makeDirectory: (path, options) =>
                path.endsWith("writers.lock")
                  ? Effect.fail(denied)
                  : fs.makeDirectory(path, options),
            }),
          ]),
        ),
      ),
      Effect.flip,
    );
    expect(error).toBe(denied);
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("refuses to initialize a missing writer registry implicitly", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const home = yield* fs.makeTempDirectoryScoped();
    const result = yield* WriterRegistry.WriterRegistry.pipe(
      Effect.flatMap((registry) => registry.update("theo", false, "https://cache.example")),
      Effect.provide(
        WriterRegistry.layer.pipe(
          Layer.provide(ConfigProvider.layer(ConfigProvider.fromUnknown({ HOME: home }))),
        ),
      ),
      Effect.exit,
    );
    expect(Exit.isFailure(result)).toBe(true);
    expect(yield* fs.exists(`${home}/.config/t3-task-cache/writers.json`)).toBe(false);
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);

it.effect("keeps existing authorization if credential publication fails", () =>
  Effect.gen(function* () {
    const fs = yield* FileSystem.FileSystem;
    const home = yield* fs.makeTempDirectoryScoped();
    const state = `${home}/.config/t3-task-cache`;
    yield* fs.makeDirectory(state, { recursive: true });
    const original = '{"maria":"old-digest"}';
    yield* fs.writeFileString(`${state}/writers.json`, original);
    const error = PlatformError.systemError({
      _tag: "PermissionDenied",
      module: "FileSystem",
      method: "rename",
    });
    const result = yield* WriterRegistry.WriterRegistry.pipe(
      Effect.flatMap((registry) => registry.update("maria", false, "https://cache.example")),
      Effect.provide(
        WriterRegistry.layer.pipe(
          Layer.provide([
            ConfigProvider.layer(ConfigProvider.fromUnknown({ HOME: home })),
            Layer.succeed(FileSystem.FileSystem, {
              ...fs,
              rename: (from, to) =>
                to === `${state}/maria.json` ? Effect.fail(error) : fs.rename(from, to),
            }),
          ]),
        ),
      ),
      Effect.exit,
    );
    expect(Exit.isFailure(result)).toBe(true);
    expect(yield* fs.readFileString(`${state}/writers.json`)).toBe(original);
  }).pipe(Effect.scoped, Effect.provide(Layer.mergeAll(NodeServices.layer, NodeCrypto.layer))),
);