155 lines
9.0 KiB
TypeScript
155 lines
9.0 KiB
TypeScript
import { createHash, randomUUID } from "node:crypto";
|
|
import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
|
|
import { tmpdir } from "node:os";
|
|
import { join, resolve } from "node:path";
|
|
|
|
import { describe, expect, it } from "vitest";
|
|
|
|
import { CreditService } from "../../apps/api/src/credits.js";
|
|
import { ModelConfigurationService, modelIds, type ModelConfigCandidate } from "../../apps/api/src/model-configuration.js";
|
|
import { ModelContractEvidenceService } from "../../apps/api/src/model-contract-evidence.js";
|
|
import { ProjectService } from "../../apps/api/src/projects.js";
|
|
import { RegistrationService } from "../../apps/api/src/registration.js";
|
|
import { MockResendAdapter } from "../../apps/api/src/resend-adapter.js";
|
|
import { settleGenerationCredits } from "../../apps/worker/src/credit-settlement.js";
|
|
import { generationErrorCategories, generationErrorRegistry } from "../../apps/worker/src/generation-error-registry.js";
|
|
import { WP7_02_MODEL_IDS, productModelIdForControlledState } from "../../scripts/lib/wp7-02-external-contract.mjs";
|
|
|
|
const now = Date.parse("2026-08-04T08:00:00.000Z");
|
|
|
|
function matrix(modelId: string) {
|
|
return {
|
|
error_mapping: [...generationErrorCategories],
|
|
execution_modes: ["sync", "async", "poll"],
|
|
model_id: modelId,
|
|
pure_text: { outputs: 1, status: "passed" },
|
|
ratios: ["3:4", "1:1", "4:3", "9:16"].map((ratio) => ({ outputs: 1, ratio, status: "passed" })),
|
|
reference_image: { outputs: 1, status: "passed" },
|
|
};
|
|
}
|
|
|
|
function editable(models: ReturnType<ModelConfigurationService["read"]>["models"]): ModelConfigCandidate[] {
|
|
return models.map(({ config_version: _version, runtime_availability: _runtime, ...candidate }) => structuredClone(candidate));
|
|
}
|
|
|
|
function writeModelEvidence(modelId: string, value: unknown) {
|
|
const root = process.env.DADA_WP7_02_STATE_EVIDENCE_ROOT;
|
|
if (!root) return;
|
|
const directory = resolve(root, modelId.replaceAll(".", "_"));
|
|
mkdirSync(directory, { recursive: true });
|
|
writeFileSync(resolve(directory, "deterministic-state.json"), `${JSON.stringify(value, null, 2)}\n`);
|
|
}
|
|
|
|
describe("TDD-WP7-EXT-001 controlled deterministic state boundaries", () => {
|
|
it("proves nine errors, settlement replay, invalidation and full revalidation independently per model", () => {
|
|
const evidenceIds = new Set<string>();
|
|
for (const externalModelId of WP7_02_MODEL_IDS) {
|
|
const modelId = productModelIdForControlledState(externalModelId);
|
|
expect(modelIds).toContain(modelId);
|
|
const root = mkdtempSync(join(tmpdir(), "dada-wp7-02-state-"));
|
|
const databasePath = join(root, "dada.sqlite3");
|
|
const registration = new RegistrationService({
|
|
challengePepper: Buffer.alloc(32, 0xd1), clock: () => now,
|
|
currentPrivacyNoticeVersion: "p0a-registration-notice-v1", databasePath,
|
|
invitePepper: Buffer.alloc(32, 0xd2), resend: new MockResendAdapter(), sessionPepper: Buffer.alloc(32, 0xd3),
|
|
});
|
|
const projects = new ProjectService({ clock: () => now, databasePath });
|
|
let credits = new CreditService({ clock: () => now, databasePath });
|
|
try {
|
|
const settlements = [];
|
|
for (const outcome of ["succeeded", "failed", "rejected"] as const) {
|
|
const userId = randomUUID();
|
|
registration.database.prepare(`INSERT INTO users (
|
|
user_id, normalized_email, role, status, counts_toward_stage_limit, registration_id, created_at
|
|
) VALUES (?, ?, 'user', 'active', 1, ?, ?)`).run(userId, `${userId}@example.invalid`, randomUUID(), now);
|
|
registration.database.prepare("INSERT INTO user_profiles (user_id, creator_name, social_id) VALUES (?, 'WP7 User', '@wp7')").run(userId);
|
|
registration.database.prepare("INSERT INTO credit_accounts (user_id, available_balance, reserved_balance, updated_at) VALUES (?, 1, 0, ?)").run(userId, now);
|
|
const generationId = projects.createProjectForGeneration({ ownerId: userId, prompt: "controlled fixture", ratio: "1:1", status: "queued" }).generation.generationId;
|
|
credits.reserveGeneration({ creditCost: 1, generationId, modelId, operationKey: `generation:${generationId}:reserve`, userId });
|
|
const input = { generationId, operationKey: `generation:${generationId}:finalize`, outcome };
|
|
const first = settleGenerationCredits(credits, input);
|
|
const replay = settleGenerationCredits(credits, input);
|
|
credits.close();
|
|
credits = new CreditService({ clock: () => now, databasePath });
|
|
const restartReplay = settleGenerationCredits(credits, input);
|
|
expect(replay).toEqual(first);
|
|
expect(restartReplay).toEqual(first);
|
|
const account = credits.readAccount(userId);
|
|
const ledger = registration.database.prepare(`SELECT entry_type, COUNT(*) AS count FROM credit_ledger
|
|
WHERE user_id = ? AND entry_type IN ('generation_commit', 'generation_release') GROUP BY entry_type`).get(userId);
|
|
expect(account).toMatchObject({ availableBalance: outcome === "succeeded" ? 0 : 1, reservedBalance: 0 });
|
|
expect(ledger).toEqual({ count: 1, entry_type: outcome === "succeeded" ? "generation_commit" : "generation_release" });
|
|
settlements.push({
|
|
available_after: account.availableBalance,
|
|
ledger_entries: 1,
|
|
outcome,
|
|
reserved_after: account.reservedBalance,
|
|
replay_count: 2,
|
|
});
|
|
}
|
|
|
|
const models = new ModelConfigurationService({ clock: () => now, database: registration.database });
|
|
const contracts = new ModelContractEvidenceService({ clock: () => now, database: registration.database, models });
|
|
const firstEvidenceHash = `sha256:${createHash("sha256").update(`${modelId}:v1`).digest("hex")}`;
|
|
const first = contracts.recordVerified({
|
|
actorId: "wp7-02-controlled", expectedConfigSetVersion: 1,
|
|
evidence: {
|
|
evidence_hash: firstEvidenceHash,
|
|
evidence_ref: `wp7-02:${modelId}:first`,
|
|
matrix: matrix(modelId), model_id: modelId,
|
|
verified_at: new Date(now).toISOString(), verifier_ref: "wp7-02-controlled",
|
|
},
|
|
idempotencyKey: `wp7-02:${modelId}:first`,
|
|
});
|
|
expect(first.model.contract_validation_status).toBe("verified");
|
|
const candidates = editable(first.configuration.models);
|
|
const target = candidates.find((candidate) => candidate.model_id === modelId)!;
|
|
target.route_profile = { ...target.route_profile, contract_revision: 2 };
|
|
const changed = models.replace({
|
|
actorId: "wp7-02-controlled", expectedConfigSetVersion: 2,
|
|
idempotencyKey: `wp7-02:${modelId}:change`, models: candidates,
|
|
});
|
|
const invalidated = changed.models.find((model) => model.model_id === modelId)!;
|
|
expect(invalidated.contract_validation_status).toBe("unverified");
|
|
const secondEvidenceHash = `sha256:${createHash("sha256").update(`${modelId}:v2`).digest("hex")}`;
|
|
const revalidated = contracts.recordVerified({
|
|
actorId: "wp7-02-controlled", expectedConfigSetVersion: 3,
|
|
evidence: {
|
|
evidence_hash: secondEvidenceHash,
|
|
evidence_ref: `wp7-02:${modelId}:second`,
|
|
matrix: matrix(modelId), model_id: modelId,
|
|
verified_at: new Date(now + 1_000).toISOString(), verifier_ref: "wp7-02-controlled",
|
|
},
|
|
idempotencyKey: `wp7-02:${modelId}:second`,
|
|
});
|
|
expect(revalidated.model.contract_validation_status).toBe("verified");
|
|
expect(contracts.read(modelId, first.model.config_version)?.evidence_hash).toBe(firstEvidenceHash);
|
|
expect(contracts.read(modelId, revalidated.model.config_version)?.evidence_hash).toBe(secondEvidenceHash);
|
|
|
|
const evidenceId = `sha256:${createHash("sha256").update(`${externalModelId}:deterministic-state`).digest("hex")}`;
|
|
expect(evidenceIds.has(evidenceId)).toBe(false);
|
|
evidenceIds.add(evidenceId);
|
|
writeModelEvidence(externalModelId, {
|
|
contract_change: {
|
|
after_change: { config_set_version: 3, config_version: invalidated.config_version, status: invalidated.contract_validation_status },
|
|
after_revalidation: { config_set_version: 4, config_version: revalidated.model.config_version, status: revalidated.model.contract_validation_status },
|
|
before_change: { config_set_version: 2, config_version: first.model.config_version, status: first.model.contract_validation_status },
|
|
full_matrix_reapplied: true,
|
|
},
|
|
error_scenarios: generationErrorCategories.map((category) => ({ category, ...generationErrorRegistry[category], source: "deterministic_local", status: "passed" })),
|
|
evidence_id: evidenceId,
|
|
model_id: externalModelId,
|
|
settlements,
|
|
status: "passed",
|
|
});
|
|
} finally {
|
|
credits.close();
|
|
projects.close();
|
|
registration.close();
|
|
rmSync(root, { force: true, recursive: true });
|
|
}
|
|
}
|
|
expect(evidenceIds.size).toBe(WP7_02_MODEL_IDS.length);
|
|
});
|
|
});
|