1import assert from "node:assert/strict";
2import fs from "node:fs/promises";
3import os from "node:os";
4import path from "node:path";
5import test, { type TestContext } from "node:test";
6 
7import type { CliArgs } from "../types.ts";
8import {
9  buildMinimaxUrl,
10  buildRequestBody,
11  buildSubjectReference,
12  extractImageFromResponse,
13  parsePixelSize,
14  validateArgs,
15} from "./minimax.ts";
16 
17function useEnv(
18  t: TestContext,
19  values: Record<string, string | null>,
20): void {
21  const previous = new Map<string, string | undefined>();
22  for (const [key, value] of Object.entries(values)) {
23    previous.set(key, process.env[key]);
24    if (value == null) {
25      delete process.env[key];
26    } else {
27      process.env[key] = value;
28    }
29  }
30 
31  t.after(() => {
32    for (const [key, value] of previous.entries()) {
33      if (value == null) {
34        delete process.env[key];
35      } else {
36        process.env[key] = value;
37      }
38    }
39  });
40}
41 
42function makeArgs(overrides: Partial<CliArgs> = {}): CliArgs {
43  return {
44    prompt: null,
45    promptFiles: [],
46    imagePath: null,
47    provider: null,
48    model: null,
49    aspectRatio: null,
50    size: null,
51    quality: null,
52    imageSize: null,
53    referenceImages: [],
54    n: 1,
55    batchFile: null,
56    jobs: null,
57    json: false,
58    help: false,
59    ...overrides,
60  };
61}
62 
63test("MiniMax URL builder uses documented default and normalizes /v1 suffixes", (t) => {
64  useEnv(t, { MINIMAX_BASE_URL: null });
65  assert.equal(buildMinimaxUrl(), "https://api.minimaxi.com/v1/image_generation");
66 
67  process.env.MINIMAX_BASE_URL = "https://api.minimax.io";
68  assert.equal(buildMinimaxUrl(), "https://api.minimax.io/v1/image_generation");
69 
70  process.env.MINIMAX_BASE_URL = "https://proxy.example.com/custom/v1/";
71  assert.equal(buildMinimaxUrl(), "https://proxy.example.com/custom/v1/image_generation");
72});
73 
74test("MiniMax size parsing and validation follow documented constraints", () => {
75  assert.deepEqual(parsePixelSize("1536x1024"), { width: 1536, height: 1024 });
76  assert.deepEqual(parsePixelSize("1536*1024"), { width: 1536, height: 1024 });
77  assert.equal(parsePixelSize("wide"), null);
78 
79  validateArgs("image-01", makeArgs({ size: "1536x1024", n: 9 }));
80 
81  assert.throws(
82    () => validateArgs("image-01-live", makeArgs({ size: "1536x1024" })),
83    /only supported with model image-01/,
84  );
85  assert.throws(
86    () => validateArgs("image-01", makeArgs({ size: "1537x1024" })),
87    /divisible by 8/,
88  );
89  assert.throws(
90    () => validateArgs("image-01", makeArgs({ aspectRatio: "2.35:1" })),
91    /aspect_ratio must be one of/,
92  );
93  assert.throws(
94    () => validateArgs("image-01", makeArgs({ n: 10 })),
95    /at most 9 images/,
96  );
97});
98 
99test("MiniMax request body maps aspect ratio, size, n, and subject references", async (t) => {
100  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "minimax-test-"));
101  t.after(() => fs.rm(dir, { recursive: true, force: true }));
102 
103  const refPath = path.join(dir, "portrait.png");
104  await fs.writeFile(refPath, Buffer.from("portrait"));
105 
106  const ratioBody = await buildRequestBody(
107    "A portrait by the window",
108    "image-01",
109    makeArgs({ aspectRatio: "16:9", n: 2, referenceImages: [refPath] }),
110  );
111  assert.equal(ratioBody.aspect_ratio, "16:9");
112  assert.equal(ratioBody.n, 2);
113  assert.equal(ratioBody.response_format, "base64");
114  assert.match(ratioBody.subject_reference?.[0]?.image_file || "", /^data:image\/png;base64,/);
115 
116  const sizeBody = await buildRequestBody(
117    "A portrait by the window",
118    "image-01",
119    makeArgs({ size: "1536x1024" }),
120  );
121  assert.equal(sizeBody.width, 1536);
122  assert.equal(sizeBody.height, 1024);
123  assert.equal(sizeBody.aspect_ratio, undefined);
124});
125 
126test("MiniMax subject references require supported file types", async (t) => {
127  const dir = await fs.mkdtemp(path.join(os.tmpdir(), "minimax-ref-"));
128  t.after(() => fs.rm(dir, { recursive: true, force: true }));
129 
130  const good = path.join(dir, "portrait.jpg");
131  const bad = path.join(dir, "portrait.webp");
132  await fs.writeFile(good, Buffer.from("portrait"));
133  await fs.writeFile(bad, Buffer.from("portrait"));
134 
135  const subjectReference = await buildSubjectReference([good]);
136  assert.equal(subjectReference?.[0]?.type, "character");
137 
138  await assert.rejects(
139    () => buildSubjectReference([bad]),
140    /only supports JPG, JPEG, or PNG/,
141  );
142});
143 
144test("MiniMax response extraction supports base64 and URL payloads", async (t) => {
145  const originalFetch = globalThis.fetch;
146  t.after(() => {
147    globalThis.fetch = originalFetch;
148  });
149 
150  const fromBase64 = await extractImageFromResponse({
151    data: {
152      image_base64: [Buffer.from("hello").toString("base64")],
153    },
154  });
155  assert.equal(Buffer.from(fromBase64).toString("utf8"), "hello");
156 
157  globalThis.fetch = async () =>
158    new Response(Uint8Array.from([1, 2, 3]), {
159      status: 200,
160      headers: { "Content-Type": "image/jpeg" },
161    });
162 
163  const fromUrl = await extractImageFromResponse({
164    data: {
165      image_urls: ["https://example.com/output.jpg"],
166    },
167  });
168  assert.deepEqual([...fromUrl], [1, 2, 3]);
169 
170  await assert.rejects(
171    () => extractImageFromResponse({ base_resp: { status_code: 1001, status_msg: "blocked" } }),
172    /blocked/,
173  );
174});
175