test: reorganize flat test files into purpose-based subdirectories (phase 6)

Group 245 flat integration tests and 25 loose unit tests into
discoverable subdirectories per spec section 6:

  integration/tools/{image,video,audio,document,data}/  (156 files)
  integration/platform/                                  (64 files)
  integration/generated/                                 (14 files)
  integration/security/                                  (10 files)

  unit/security/     (8 files, new subdir)
  unit/api/          (7 files moved in)
  unit/web/          (3 files moved in)
  unit/shared/       (6 files moved in)
  unit/image-engine/ (1 file moved in)

All moves via git mv (history preserved). Relative imports repaired
for both depth levels (platform/generated/security = +1, tools/ = +2):
static from-imports, dynamic import() calls, vi.mock() paths,
import.meta.dirname joins, and __dirname joins.

Vitest discovery unchanged (no test.include in config, recursive glob
matches subdirs, shard-by-hash unaffected). test-server.ts and
tool-route-drift.test.ts stay at integration root. fixtures/ untouched.

Parity gate: 13189 passing test names before = 13189 after (0 dropped).
This commit is contained in:
SnapOtter
2026-06-20 05:07:46 +08:00
parent 257f030c09
commit 1727a7a73e
269 changed files with 1553 additions and 619 deletions
@@ -0,0 +1,286 @@
/**
* Integration tests for the noise-removal AI tool (/api/v1/tools/noise-removal).
*
* The Python sidecar may not be running, so processing tests accept both
* 200 (sidecar available) and 501 (feature not installed). Validation paths
* are always testable.
*/
import { afterAll, beforeAll, describe, expect, it } from "vitest";
import { fixtures, readFixture } from "../../../fixtures/index.js";
import {
buildTestApp,
createMultipartPayload,
loginAsAdmin,
type TestApp,
} from "../../test-server.js";
const PNG = readFixture(fixtures.image.base.png200);
const HEIC = readFixture(fixtures.image.base.heic200);
const TINY = readFixture(fixtures.image.edge.px1);
let testApp: TestApp;
let app: TestApp["app"];
let adminToken: string;
beforeAll(async () => {
testApp = await buildTestApp();
app = testApp.app;
adminToken = await loginAsAdmin(app);
}, 30_000);
afterAll(async () => {
await testApp.cleanup();
}, 10_000);
describe("noise-removal", () => {
// ── Processing (sidecar-dependent) ────────────────────────────────
it("responds to the route (202 or 501)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
{ name: "settings", content: JSON.stringify({}) },
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([202, 501]).toContain(res.statusCode);
}, 60_000);
it("processes with default settings (202 or 501)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([202, 501]).toContain(res.statusCode);
if (res.statusCode === 202) {
const result = JSON.parse(res.body);
expect(result.jobId).toBeDefined();
expect(result.async).toBe(true);
}
}, 60_000);
it("accepts tier=quick (202 or 501)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
{
name: "settings",
content: JSON.stringify({ tier: "quick" }),
},
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([202, 501]).toContain(res.statusCode);
}, 60_000);
it("accepts tier=quality with explicit strength (202 or 501)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
{
name: "settings",
content: JSON.stringify({ tier: "quality", strength: 80 }),
},
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([202, 501]).toContain(res.statusCode);
}, 60_000);
it("accepts tier=maximum (202 or 501)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
{
name: "settings",
content: JSON.stringify({ tier: "maximum" }),
},
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([202, 501]).toContain(res.statusCode);
}, 60_000);
it("accepts all explicit settings (202 or 501)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
{
name: "settings",
content: JSON.stringify({
tier: "balanced",
strength: 60,
detailPreservation: 70,
colorNoise: 40,
format: "jpeg",
quality: 85,
}),
},
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([202, 501]).toContain(res.statusCode);
}, 60_000);
it(
"handles HEIC input (202 or 501)",
{ timeout: 120_000 },
async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "photo.heic", contentType: "image/heic", content: HEIC },
{ name: "settings", content: JSON.stringify({}) },
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([202, 501]).toContain(res.statusCode);
},
60_000,
);
it("handles 1x1 pixel input (200, 422, or 501)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "tiny.png", contentType: "image/png", content: TINY },
{ name: "settings", content: JSON.stringify({}) },
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([202, 422, 501]).toContain(res.statusCode);
}, 60_000);
// ── Validation (always testable) ──────────────────────────────────
it("rejects requests without a file (400)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "settings", content: JSON.stringify({ tier: "quick" }) },
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
// 400 when sidecar is available, 501 when not (isToolInstalled check fires first)
expect([400, 501]).toContain(res.statusCode);
if (res.statusCode === 400) {
const json = JSON.parse(res.body);
expect(json.error).toMatch(/no image/i);
}
});
it("rejects invalid settings JSON (400)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
{ name: "settings", content: "not-valid-json!!!" },
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([400, 501]).toContain(res.statusCode);
});
it("rejects invalid tier value (400)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
{
name: "settings",
content: JSON.stringify({ tier: "ultra" }),
},
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([400, 501]).toContain(res.statusCode);
});
it("rejects invalid format value (400)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
{
name: "settings",
content: JSON.stringify({ format: "bmp" }),
},
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { authorization: `Bearer ${adminToken}`, "content-type": contentType },
body,
});
expect([400, 501]).toContain(res.statusCode);
});
it("rejects unauthenticated requests (401)", async () => {
const { body, contentType } = createMultipartPayload([
{ name: "file", filename: "test.png", contentType: "image/png", content: PNG },
{ name: "settings", content: JSON.stringify({}) },
]);
const res = await app.inject({
method: "POST",
url: "/api/v1/tools/noise-removal",
headers: { "content-type": contentType },
body,
});
expect(res.statusCode).toBe(401);
});
});