Files
clean-architecture-frontend…/tests/contract/consumer-experience/indexeddb-local-draft.test.ts
T
DongHyeonkaandClaude Opus 5.5 070d4dbe9c test(features): probe the one local-draft implementation (09-12)
The consumer-experience probe ran and scanned a fixture copy of local-draft
that had drifted from src. The copy is gone; the probe runs the src store and
scans every local-draft source file, and the measured table now describes it.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-25 23:29:22 +09:00

175 lines
5.3 KiB
TypeScript

import { readdir, readFile } from "node:fs/promises";
import path from "node:path";
import { describe, expect, it } from "vitest";
import type {
BrowserDataResult,
IndexedDbRepositoryPort,
} from "../../../src/application/ports/browser-file-storage/index.ts";
import { createLocalDraftStore } from "../../../src/features/local-draft-feature/adapters/local-draft-indexeddb-store.ts";
import type { LocalDraft } from "../../../src/features/local-draft-feature/domain/local-draft.ts";
// 09-12. This probe used to exercise a copy of the feature under fixtures/,
// which had drifted from src (it returned raw storage failures). It now reads
// and runs the one implementation.
const FEATURE_ROOT = "src/features/local-draft-feature";
async function featureSources(directory: string): Promise<string[]> {
const entries = await readdir(directory, { withFileTypes: true });
const nested = await Promise.all(
entries.map((entry) => {
const target = path.join(directory, entry.name);
if (entry.isDirectory()) return featureSources(target);
return /\.tsx?$/u.test(entry.name) ? [target] : [];
}),
);
return nested.flat();
}
function success<Value>(value: Value): BrowserDataResult<Value> {
return Object.freeze({ ok: true as const, value });
}
function repositoryFixture(): IndexedDbRepositoryPort<LocalDraft, never> {
let stored: Readonly<{ value: LocalDraft; revision: number }> | null = null;
const repository: IndexedDbRepositoryPort<LocalDraft, never> = {
async open() {
return success(undefined);
},
async read(key) {
if (stored === null || stored.value.draftId !== key) {
return success(null);
}
return success(stored);
},
async query() {
return success(Object.freeze({ items: [], nextCursor: null }));
},
async compareAndSwap(input) {
const currentRevision = stored?.revision ?? null;
if (currentRevision !== input.expectedRevision) {
return Object.freeze({
ok: false as const,
error: Object.freeze({
code: "CONFLICT" as const,
operation: "INDEXEDDB_WRITE" as const,
retryable: false,
recovery: "RECONCILE" as const,
}),
});
}
const revision = (currentRevision ?? 0) + 1;
stored = Object.freeze({ value: input.value, revision });
return success(
Object.freeze({
key: input.key,
revision,
replayed: false,
}),
);
},
async remove(input) {
if (stored === null || stored.revision !== input.expectedRevision) {
return Object.freeze({
ok: false as const,
error: Object.freeze({
code: "CONFLICT" as const,
operation: "INDEXEDDB_WRITE" as const,
retryable: false,
recovery: "RECONCILE" as const,
}),
});
}
stored = null;
return success(
Object.freeze({
key: input.key,
revision: input.expectedRevision + 1,
replayed: false,
}),
);
},
async enforceLifecycleBatch() {
stored = null;
return success(
Object.freeze({
state: "COMPLETE" as const,
scannedRows: 0,
deletedRows: 0,
budgetExhausted: false,
}),
);
},
getStatus() {
return Object.freeze({ kind: "READY" as const, schemaVersion: 1 });
},
subscribeStatus() {
return () => {};
},
close() {},
};
return Object.freeze(repository);
}
describe("IndexedDB local-draft consumer experience", () => {
it("implements save/find/remove through the public application port", async () => {
const store = createLocalDraftStore(repositoryFixture());
const draft = Object.freeze({
draftId: "draft-1",
title: "Architecture notes",
body: "Feature code owns the draft model.",
});
await expect(
store.save({
draft,
expectedRevision: null,
idempotencyKey: "draft-save-0001",
}),
).resolves.toEqual({ ok: true, value: { revision: 1 } });
await expect(store.find("draft-1")).resolves.toEqual({
ok: true,
value: { draft, revision: 1 },
});
await expect(
store.remove({
draftId: "draft-1",
expectedRevision: 1,
idempotencyKey: "draft-remove-0001",
}),
).resolves.toEqual({ ok: true, value: undefined });
await expect(store.find("draft-1")).resolves.toEqual({
ok: true,
value: null,
});
});
it("keeps native IndexedDB and the storage runtime out of feature-owned code", async () => {
const files = await featureSources(FEATURE_ROOT);
expect(files.length).toBeGreaterThan(0);
for (const file of files) {
const source = await readFile(file, "utf8");
for (const forbidden of [
"adapters/storage/indexeddb",
"application/ports/browser-file-storage",
"globalThis.indexedDB",
"IDBFactory",
"IDBDatabase",
"IDBTransaction",
"IDBObjectStore",
]) {
const importsOrUses = source
.split("\n")
.filter((line) => !/^\s*(?:\*|\/\/)/u.test(line))
.some((line) => line.includes(forbidden));
expect(importsOrUses, `${file} uses ${forbidden}`).toBe(false);
}
}
});
});