355 lines
13 KiB
TypeScript
355 lines
13 KiB
TypeScript
// @vitest-environment node
|
||
import { createHash } from "node:crypto";
|
||
import { readFileSync, readdirSync } from "node:fs";
|
||
import { expect, it } from "vitest";
|
||
import { ENVIRONMENTS } from "../src/content";
|
||
|
||
// 생성기 자기 보고 대신 배포 바이트의 형식·파형·권리 추적 정보를 독립 측정한다.
|
||
it("여덟 현장 녹음은 고유 PCM16 WAV·짧은 fade·완전한 provenance/notice를 가진다", () => {
|
||
const manifest = JSON.parse(
|
||
readFileSync("public/ambience/manifest.json", "utf8"),
|
||
);
|
||
expect(manifest.version).toBe("0.2.3");
|
||
expect(
|
||
manifest.files.map((f: { environmentId: string }) => f.environmentId),
|
||
).toEqual(ENVIRONMENTS.map((e) => e.id));
|
||
expect(readdirSync("public/ambience").sort()).toEqual(
|
||
[
|
||
...ENVIRONMENTS.map((e) => `${e.id}.wav`),
|
||
"manifest.json",
|
||
"AMBIENCE_NOTICES.md",
|
||
].sort(),
|
||
);
|
||
const notice = readFileSync("public/ambience/AMBIENCE_NOTICES.md", "utf8");
|
||
const hashes = new Set();
|
||
for (const entry of manifest.files) {
|
||
for (const key of [
|
||
"displayName",
|
||
"pageUrl",
|
||
"directUrl",
|
||
"creator",
|
||
"license",
|
||
"licenseUrl",
|
||
"attribution",
|
||
"conversion",
|
||
"sourceSha256",
|
||
"sha256",
|
||
"bytes",
|
||
"duration",
|
||
"rms",
|
||
"peak",
|
||
])
|
||
expect(entry[key], key).toBeTruthy();
|
||
expect(entry.sourceSha256).toMatch(/^[a-f0-9]{64}$/);
|
||
expect(entry.license).toMatch(/CC0|Public domain|CC BY(?:-SA)? 4\.0/);
|
||
const section = notice
|
||
.split("## ")
|
||
.find((s: string) =>
|
||
s.startsWith(`${entry.displayName} — ${entry.environmentId}\n`),
|
||
)!;
|
||
expect(section).toContain(entry.attribution);
|
||
for (const line of [
|
||
`Creator: ${entry.creator}`,
|
||
`Source: ${entry.pageUrl}`,
|
||
`Download: ${entry.directUrl}`,
|
||
`License: ${entry.license} — ${entry.licenseUrl}`,
|
||
`Output license: ${entry.outputLicense}`,
|
||
`Changes: ${entry.conversion.operations}`,
|
||
])
|
||
expect(section).toContain(line);
|
||
expect(notice).toContain(entry.licenseUrl);
|
||
expect(notice).toContain(entry.pageUrl);
|
||
const bytes = readFileSync(`public/ambience/${entry.file}`);
|
||
const hash = createHash("sha256").update(bytes).digest("hex");
|
||
hashes.add(hash);
|
||
expect(hash).toBe(entry.sha256);
|
||
expect(bytes.length).toBe(entry.bytes);
|
||
expect(bytes.toString("ascii", 0, 4)).toBe("RIFF");
|
||
expect(bytes.toString("ascii", 8, 12)).toBe("WAVE");
|
||
expect(bytes.readUInt16LE(20)).toBe(1);
|
||
expect(bytes.readUInt16LE(22)).toBe(1);
|
||
expect(bytes.readUInt32LE(24)).toBe(24000);
|
||
expect(bytes.readUInt16LE(34)).toBe(16);
|
||
expect(bytes.readUInt32LE(40)).toBe(bytes.length - 44);
|
||
const samples = Array.from(
|
||
{ length: (bytes.length - 44) / 2 },
|
||
(_, i) => bytes.readInt16LE(44 + i * 2) / 32768,
|
||
);
|
||
const rms = Math.sqrt(
|
||
samples.reduce((sum, n) => sum + n * n, 0) / samples.length,
|
||
);
|
||
const peak = samples.reduce((max, n) => Math.max(max, Math.abs(n)), 0);
|
||
expect(rms).toBeCloseTo(entry.rms, 10);
|
||
expect(peak).toBeCloseTo(entry.peak, 10);
|
||
expect(rms).toBeGreaterThan(0.003);
|
||
expect(peak).toBeLessThanOrEqual(0.85);
|
||
expect(samples[0]).toBe(0);
|
||
expect(samples.at(-1)).toBe(0);
|
||
expect(entry.duration).toBe(samples.length / 24000);
|
||
expect(entry.duration).toBeGreaterThanOrEqual(8);
|
||
expect(entry.duration).toBeLessThanOrEqual(20);
|
||
expect(entry.conversion.fadeSeconds).toBeGreaterThanOrEqual(0.025);
|
||
expect(entry.conversion.startSeconds).toBeGreaterThanOrEqual(0);
|
||
}
|
||
expect(hashes.size).toBe(8);
|
||
});
|
||
|
||
it("원본 계획은 임시 경로 대신 검증된 해시·바이트·직접 미디어 길이를 고정한다", () => {
|
||
const plan = JSON.parse(
|
||
readFileSync(".agent/AMBIENCE-SOURCES-v0.2.3.json", "utf8"),
|
||
);
|
||
const manifest = JSON.parse(
|
||
readFileSync("public/ambience/manifest.json", "utf8"),
|
||
);
|
||
const evidence = JSON.parse(
|
||
readFileSync(".agent/evidence-v0.2.3/source-integrity.json", "utf8"),
|
||
);
|
||
for (const [index, asset] of plan.assets.entries()) {
|
||
const original = evidence.find(
|
||
(e: { file: string }) => e.file.split(".")[0] === asset.environmentId,
|
||
);
|
||
expect.soft(asset).not.toHaveProperty("verifiedLocalSource");
|
||
expect.soft(asset).not.toHaveProperty("sourceDurationSeconds");
|
||
expect.soft(asset.expectedSourceSha256).toBe(original.sha256);
|
||
expect.soft(asset.sourceBytes).toBe(original.bytes);
|
||
expect
|
||
.soft(asset.directMediaDurationSeconds)
|
||
.toBe(Number(original.probe.format.duration));
|
||
expect.soft(asset.sourceVerification).toEqual({
|
||
status: "verified",
|
||
dateUtc: "2026-10-14",
|
||
method:
|
||
"SHA-256, byte count, ffprobe format.duration, full FFmpeg decode",
|
||
evidence: ".agent/evidence-v0.2.3/source-integrity.json",
|
||
});
|
||
expect.soft(manifest.files[index]).toMatchObject(asset);
|
||
expect
|
||
.soft(manifest.files[index].sourceSha256)
|
||
.toBe(asset.expectedSourceSha256);
|
||
}
|
||
});
|
||
|
||
it("선택 구간은 승인 계획의 불변 provenance이며 manifest와 고지에 동일하게 남는다", () => {
|
||
const plan = JSON.parse(
|
||
readFileSync(".agent/AMBIENCE-SOURCES-v0.2.3.json", "utf8"),
|
||
);
|
||
const manifest = JSON.parse(
|
||
readFileSync("public/ambience/manifest.json", "utf8"),
|
||
);
|
||
const notice = readFileSync("public/ambience/AMBIENCE_NOTICES.md", "utf8");
|
||
const starts = {
|
||
street: 35,
|
||
mall: 36,
|
||
theater: 45,
|
||
department: 90,
|
||
market: 24,
|
||
subway: 65,
|
||
cafe: 0,
|
||
rain: 180,
|
||
};
|
||
expect(
|
||
Object.fromEntries(
|
||
plan.assets.map(
|
||
(asset: {
|
||
environmentId: string;
|
||
selectedSegmentStartSeconds: number;
|
||
}) => [asset.environmentId, asset.selectedSegmentStartSeconds],
|
||
),
|
||
),
|
||
).toEqual(starts);
|
||
for (const asset of plan.assets) {
|
||
const start = asset.selectedSegmentStartSeconds;
|
||
expect(Number.isFinite(start)).toBe(true);
|
||
expect(start).toBeGreaterThanOrEqual(0);
|
||
expect(start + 12).toBeLessThanOrEqual(asset.directMediaDurationSeconds);
|
||
const entry = manifest.files.find(
|
||
(e: { environmentId: string }) => e.environmentId === asset.environmentId,
|
||
);
|
||
expect(entry.selectedSegmentStartSeconds).toBe(start);
|
||
expect(entry.conversion.startSeconds).toBe(start);
|
||
expect(entry.conversion.durationSeconds).toBe(12);
|
||
const section = notice
|
||
.split("## ")
|
||
.find((s: string) =>
|
||
s.startsWith(`${asset.displayName} — ${asset.environmentId}\n`),
|
||
);
|
||
expect(section).toContain(`source seconds ${start}–${start + 12}.`);
|
||
}
|
||
});
|
||
|
||
it("최종 ASR 증거는 정확한 WAV와 연결되며 청취·법적 인수로 주장하지 않는다", () => {
|
||
const directory = ".agent/evidence-v0.2.3/privacy-screening";
|
||
const screening = JSON.parse(
|
||
readFileSync(`${directory}/final-asr.json`, "utf8"),
|
||
);
|
||
const manifest = JSON.parse(
|
||
readFileSync("public/ambience/manifest.json", "utf8"),
|
||
);
|
||
expect(screening.tool).toMatchObject({
|
||
name: "faster-whisper",
|
||
version: "1.2.1",
|
||
});
|
||
expect(screening.model).toMatchObject({ name: "tiny", multilingual: true });
|
||
expect(screening.model.revision).toMatch(/^[a-f0-9]{40}$/);
|
||
expect(screening.requiredEmptyPassed).toBe(true);
|
||
expect(screening.requiredEmptyEnvironmentIds).toEqual([
|
||
"mall",
|
||
"market",
|
||
"cafe",
|
||
]);
|
||
expect(screening.method).toMatchObject({
|
||
device: "cpu",
|
||
computeType: "int8",
|
||
});
|
||
expect(screening.method.parameters).toMatchObject({
|
||
task: "transcribe",
|
||
language: null,
|
||
beam_size: 5,
|
||
best_of: 5,
|
||
vad_filter: true,
|
||
vad_parameters: null,
|
||
condition_on_previous_text: true,
|
||
});
|
||
expect(screening.method.manifestSha256).toBe(
|
||
createHash("sha256")
|
||
.update(readFileSync("public/ambience/manifest.json"))
|
||
.digest("hex"),
|
||
);
|
||
expect(screening.limitations).toMatchObject({
|
||
screeningOnly: true,
|
||
humanListeningAcceptance: false,
|
||
legalPrivacyClearance: false,
|
||
textIsVerifiedTranscript: false,
|
||
});
|
||
expect(
|
||
screening.files.map((e: { environmentId: string }) => e.environmentId),
|
||
).toEqual(ENVIRONMENTS.map((e) => e.id));
|
||
for (const entry of manifest.files) {
|
||
const result = screening.files.find(
|
||
(e: { environmentId: string }) => e.environmentId === entry.environmentId,
|
||
);
|
||
expect(result).toMatchObject({
|
||
file: `public/ambience/${entry.file}`,
|
||
sha256: entry.sha256,
|
||
bytes: entry.bytes,
|
||
durationSeconds: entry.duration,
|
||
selectedSegmentStartSeconds: entry.selectedSegmentStartSeconds,
|
||
sourceSha256: entry.sourceSha256,
|
||
});
|
||
expect(result.language).toEqual(expect.any(String));
|
||
expect(result.languageProbability).toEqual(expect.any(Number));
|
||
expect(Array.isArray(result.segments)).toBe(true);
|
||
if (["mall", "market", "cafe"].includes(entry.environmentId)) {
|
||
const starts: Record<string, number> = { mall: 36, market: 24, cafe: 0 };
|
||
expect(result.selectedSegmentStartSeconds).toBe(
|
||
starts[entry.environmentId],
|
||
);
|
||
expect(result.segments).toEqual([]);
|
||
expect(result.text).toBe("");
|
||
expect(result.info.duration_after_vad).toBe(0);
|
||
}
|
||
}
|
||
const provenance = JSON.parse(
|
||
readFileSync(`${directory}/earlier-asr-provenance.json`, "utf8"),
|
||
);
|
||
expect(provenance.textIsVerifiedTranscript).toBe(false);
|
||
for (const record of provenance.records)
|
||
expect(
|
||
createHash("sha256")
|
||
.update(readFileSync(`${directory}/${record.savedFile}`))
|
||
.digest("hex"),
|
||
).toBe(record.sha256);
|
||
});
|
||
|
||
it("101개 음성·다섯 현장음 및 이전 evidence 바이트를 보존한다", () => {
|
||
const baseline = JSON.parse(
|
||
readFileSync(
|
||
".agent/evidence-v0.2.3/privacy-screening/baseline.json",
|
||
"utf8",
|
||
),
|
||
);
|
||
let voices = 0,
|
||
unchangedAmbience = 0,
|
||
changedAmbience = 0;
|
||
for (const [path, before] of Object.entries(baseline.wavSha256)) {
|
||
const actual = createHash("sha256")
|
||
.update(readFileSync(path))
|
||
.digest("hex");
|
||
if (/public\/ambience\/(mall|market|cafe)\.wav$/.test(path)) {
|
||
expect(actual).not.toBe(before);
|
||
changedAmbience++;
|
||
} else {
|
||
expect(actual).toBe(before);
|
||
if (path.startsWith("public/audio/")) voices++;
|
||
else unchangedAmbience++;
|
||
}
|
||
}
|
||
expect([voices, unchangedAmbience, changedAmbience]).toEqual([101, 5, 3]);
|
||
for (const [path, before] of Object.entries(baseline.priorAgentFiles)) {
|
||
if (baseline.mutableAgentFiles.includes(path)) continue;
|
||
expect(
|
||
createHash("sha256").update(readFileSync(path)).digest("hex"),
|
||
path,
|
||
).toBe(before);
|
||
}
|
||
});
|
||
|
||
it("재시도는 market/cafe만 바꾸고 mall 및 실패·no-VAD 증거를 바이트 그대로 보존한다", () => {
|
||
const directory = ".agent/evidence-v0.2.3/privacy-screening";
|
||
const baseline = JSON.parse(
|
||
readFileSync(`${directory}/retry-market24-cafe0/baseline.json`, "utf8"),
|
||
);
|
||
const hash = (path: string) =>
|
||
createHash("sha256").update(readFileSync(path)).digest("hex");
|
||
const prior = `${directory}/prior-attempt-market60-cafe180`;
|
||
expect(hash(`${prior}/final-asr.json`)).toBe(
|
||
"01c8a92fab9f8df7a5f778c5f7e478ce96bcedc33e11a1055bd29154a08b706b",
|
||
);
|
||
const failed = JSON.parse(readFileSync(`${prior}/final-asr.json`, "utf8"));
|
||
expect(failed.requiredEmptyPassed).toBe(false);
|
||
expect(failed.limitations).toMatchObject({
|
||
humanListeningAcceptance: false,
|
||
legalPrivacyClearance: false,
|
||
});
|
||
for (const [environmentId, start, count] of [
|
||
["mall", 36, 0],
|
||
["market", 60, 3],
|
||
["cafe", 180, 1],
|
||
]) {
|
||
const result = failed.files.find(
|
||
(f: { environmentId: string }) => f.environmentId === environmentId,
|
||
);
|
||
expect(result.selectedSegmentStartSeconds).toBe(start);
|
||
expect(result.segments).toHaveLength(count as number);
|
||
}
|
||
expect(hash(`${directory}/no-vad-asr.json`)).toBe(
|
||
"14b42ee0b80c194caa3c0de2644f647d6d7720c60c2208374778619f47c2e969",
|
||
);
|
||
for (const [path, before] of Object.entries(
|
||
baseline.immutablePriorAttemptFiles,
|
||
))
|
||
expect(hash(path), path).toBe(before);
|
||
for (const [path, before] of Object.entries(baseline.priorAgentFiles)) {
|
||
if (!baseline.mutableAgentFiles.includes(path))
|
||
expect(hash(path), path).toBe(before);
|
||
}
|
||
const changed: string[] = [];
|
||
let voices = 0,
|
||
preservedAmbience = 0;
|
||
for (const [path, before] of Object.entries(baseline.wavSha256)) {
|
||
if (/public\/ambience\/(market|cafe)\.wav$/.test(path)) {
|
||
expect(hash(path), path).not.toBe(before);
|
||
changed.push(path);
|
||
} else {
|
||
expect(hash(path), path).toBe(before);
|
||
if (path.startsWith("public/audio/")) voices++;
|
||
else preservedAmbience++;
|
||
}
|
||
}
|
||
expect(changed.sort()).toEqual([
|
||
"public/ambience/cafe.wav",
|
||
"public/ambience/market.wav",
|
||
]);
|
||
expect([voices, preservedAmbience]).toEqual([101, 6]);
|
||
});
|