1

server-node/src/services/sceneImageService.test.ts

@@ -0,0 +1,199 @@
+import assert from 'node:assert/strict';
+import { createServer, type IncomingMessage, type ServerResponse } from 'node:http';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import test from 'node:test';
+
+import type { AppContext } from '../context.js';
+import { type AppConfig } from '../config.js';
+import { generateSceneImage } from './sceneImageService.js';
+
+const PNG_BUFFER = Buffer.from(
+  'iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO7+7aQAAAAASUVORK5CYII=',
+  'base64',
+);
+
+function createTestConfig(
+  projectRoot: string,
+  dashScopeBaseUrl: string,
+): AppConfig {
+  return {
+    projectRoot,
+    publicDir: path.join(projectRoot, 'public'),
+    dashScope: {
+      baseUrl: dashScopeBaseUrl,
+      apiKey: 'test-dashscope-key',
+      imageModel: 'wan2.7-image',
+      requestTimeoutMs: 5_000,
+    },
+  } as AppConfig;
+}
+
+function readRequestBody(req: IncomingMessage) {
+  return new Promise<Buffer>((resolve, reject) => {
+    const chunks: Buffer[] = [];
+    req.on('data', (chunk) => {
+      chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    });
+    req.on('end', () => resolve(Buffer.concat(chunks)));
+    req.on('error', reject);
+  });
+}
+
+function sendJson(res: ServerResponse, payload: unknown) {
+  res.statusCode = 200;
+  res.setHeader('Content-Type', 'application/json; charset=utf-8');
+  res.end(JSON.stringify(payload));
+}
+
+async function withHttpServer<T>(
+  buildHandler: (baseUrl: string) => (
+    req: IncomingMessage,
+    res: ServerResponse,
+  ) => void | Promise<void>,
+  run: (baseUrl: string) => Promise<T>,
+) {
+  let handler: (
+    req: IncomingMessage,
+    res: ServerResponse,
+  ) => void | Promise<void> = () => undefined;
+  const server = createServer((req, res) => {
+    Promise.resolve(handler(req, res)).catch((error) => {
+      res.statusCode = 500;
+      res.end(error instanceof Error ? error.stack : String(error));
+    });
+  });
+
+  await new Promise<void>((resolve) => {
+    server.listen(0, '127.0.0.1', () => resolve());
+  });
+
+  const address = server.address();
+  if (!address || typeof address === 'string') {
+    throw new Error('failed to resolve test server address');
+  }
+
+  const baseUrl = `http://127.0.0.1:${address.port}`;
+  handler = buildHandler(baseUrl);
+
+  try {
+    return await run(baseUrl);
+  } finally {
+    await new Promise<void>((resolve, reject) => {
+      server.close((error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+        resolve();
+      });
+    });
+  }
+}
+
+test('generateSceneImage uploads a public reference image as a data url and saves the generated scene', async () => {
+  const tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'genarrative-scene-image-'));
+  const publicDir = path.join(tempRoot, 'public');
+  fs.mkdirSync(path.join(publicDir, 'scene_bg'), { recursive: true });
+  fs.writeFileSync(path.join(publicDir, 'scene_bg', 'reference-layout.png'), PNG_BUFFER);
+
+  const capturedRequests: Array<{
+    pathname: string;
+    bodyText?: string;
+  }> = [];
+
+  await withHttpServer(
+    (baseUrl) => async (req, res) => {
+      const url = new URL(req.url || '/', baseUrl);
+      const bodyText =
+        req.method === 'POST' ? (await readRequestBody(req)).toString('utf8') : undefined;
+      capturedRequests.push({
+        pathname: url.pathname,
+        bodyText,
+      });
+
+      if (
+        req.method === 'POST' &&
+        url.pathname === '/api/v1/services/aigc/image-generation/generation'
+      ) {
+        sendJson(res, {
+          output: {
+            task_id: 'scene-task-1',
+          },
+        });
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/api/v1/tasks/scene-task-1') {
+        sendJson(res, {
+          output: {
+            task_status: 'SUCCEEDED',
+            results: [
+              {
+                url: `${baseUrl}/downloads/scene.png`,
+                actual_prompt: '整理后的场景提示词',
+              },
+            ],
+          },
+        });
+        return;
+      }
+
+      if (req.method === 'GET' && url.pathname === '/downloads/scene.png') {
+        res.statusCode = 200;
+        res.setHeader('Content-Type', 'image/png');
+        res.end(PNG_BUFFER);
+        return;
+      }
+
+      res.statusCode = 404;
+      res.end('not found');
+    },
+    async (dashScopeBaseUrl) => {
+      const context = {
+        config: createTestConfig(tempRoot, `${dashScopeBaseUrl}/api/v1`),
+      } as AppContext;
+
+      const result = await generateSceneImage(context, {
+        prompt: '海雾港口像素风场景',
+        negativePrompt: '模糊',
+        size: '1280*720',
+        model: 'wan2.7-image',
+        worldName: '潮雾群岛',
+        profileId: 'world-1',
+        landmarkName: '旧港灯塔',
+        landmarkId: 'landmark-1',
+        referenceImageSrc: '/scene_bg/reference-layout.png',
+      });
+
+      assert.equal(result.ok, true);
+      assert.match(result.imageSrc, /^\/generated-custom-world-scenes\//u);
+      assert.equal(result.actualPrompt, '整理后的场景提示词');
+
+      const createRequest = capturedRequests.find(
+        (entry) => entry.pathname === '/api/v1/services/aigc/image-generation/generation',
+      );
+      assert.ok(createRequest?.bodyText);
+
+      const createPayload = JSON.parse(createRequest.bodyText) as {
+        input: {
+          messages: Array<{
+            content: Array<{ text?: string; image?: string }>;
+          }>;
+        };
+        parameters: {
+          negative_prompt?: string;
+        };
+      };
+
+      const content = createPayload.input.messages[0]?.content ?? [];
+      assert.equal(content[0]?.text, '海雾港口像素风场景');
+      assert.match(content[1]?.image ?? '', /^data:image\/png;base64,/u);
+      assert.equal(createPayload.parameters.negative_prompt, '模糊');
+
+      const savedImagePath = path.join(tempRoot, 'public', result.imageSrc.slice(1));
+      assert.equal(fs.existsSync(savedImagePath), true);
+    },
+  );
+});