Merge pull request #156 from NianJiuZst/test/complete-core-coverage

test: comprehensive test coverage improvements (pure functions, SDK validation, command tests)

Author: RyanLee-Dev

test/commands/file/upload.test.ts

@@ -1,38 +1,61 @@
 import { describe, it, expect } from 'bun:test';
 import { default as uploadCommand } from '../../../src/commands/file/upload';
 
+const baseConfig = {
+  apiKey: 'test-key',
+  region: 'global' as const,
+  baseUrl: 'https://api.mmx.io',
+  output: 'text' as const,
+  timeout: 10,
+  verbose: false,
+  quiet: false,
+  noColor: true,
+  yes: false,
+  dryRun: false,
+  nonInteractive: true,
+  async: false,
+};
+
+const baseFlags = {
+  quiet: false,
+  verbose: false,
+  noColor: true,
+  yes: false,
+  dryRun: false,
+  help: false,
+  nonInteractive: true,
+  async: false,
+};
+
 describe('file upload command', () => {
   it('has correct name', () => {
     expect(uploadCommand.name).toBe('file upload');
   });
 
-  it('requires file argument', async () => {
-    const config = {
-      apiKey: 'test-key',
-      region: 'global' as const,
-      baseUrl: 'https://api.mmx.io',
-      output: 'text' as const,
-      timeout: 10,
-      verbose: false,
-      quiet: false,
-      noColor: true,
-      yes: false,
-      dryRun: true,
-      nonInteractive: true,
-      async: false,
-    };
-
+  it('requires file argument in non-interactive mode', async () => {
     await expect(
-      uploadCommand.execute(config, {
-        quiet: false,
-        verbose: false,
-        noColor: true,
-        yes: false,
-        dryRun: true,
-        help: false,
-        nonInteractive: true,
-        async: false,
-      }),
+      uploadCommand.execute(baseConfig, baseFlags),
     ).rejects.toThrow('Missing required argument: --file');
   });
+
+  it('throws when file does not exist', async () => {
+    await expect(
+      uploadCommand.execute(baseConfig, { ...baseFlags, file: '/tmp/nonexistent-file-xxxxx.bin' }),
+    ).rejects.toThrow('File not found');
+  });
+
+  it('shows dry-run output with file info', async () => {
+    let captured = '';
+    const origWrite = process.stdout.write;
+    process.stdout.write = (chunk: any): any => { captured += String(chunk); return true; };
+
+    await uploadCommand.execute(
+      { ...baseConfig, dryRun: true },
+      { ...baseFlags, dryRun: true, file: '/dev/null', purpose: 'vision' },
+    );
+
+    process.stdout.write = origWrite;
+    expect(captured).toContain('/dev/null');
+    expect(captured).toContain('vision');
+  });
 });

test/commands/image/generate.test.ts

@@ -1,38 +1,94 @@
 import { describe, it, expect } from 'bun:test';
 import { default as generateCommand } from '../../../src/commands/image/generate';
 
+const baseConfig = {
+  apiKey: 'test-key',
+  region: 'global' as const,
+  baseUrl: 'https://api.mmx.io',
+  output: 'text' as const,
+  timeout: 10,
+  verbose: false,
+  quiet: false,
+  noColor: true,
+  yes: false,
+  dryRun: false,
+  nonInteractive: true,
+  async: false,
+};
+
+const baseFlags = {
+  quiet: false,
+  verbose: false,
+  noColor: true,
+  yes: false,
+  dryRun: false,
+  help: false,
+  nonInteractive: true,
+  async: false,
+};
+
 describe('image generate command', () => {
   it('has correct name', () => {
     expect(generateCommand.name).toBe('image generate');
   });
 
   it('requires prompt', async () => {
-    const config = {
-      apiKey: 'test-key',
-      region: 'global' as const,
-      baseUrl: 'https://api.mmx.io',
-      output: 'text' as const,
-      timeout: 10,
-      verbose: false,
-      quiet: false,
-      noColor: true,
-      yes: false,
-      dryRun: false,
-      nonInteractive: true,
-      async: false,
-    };
-
     await expect(
-      generateCommand.execute(config, {
-        quiet: false,
-        verbose: false,
-        noColor: true,
-        yes: false,
-        dryRun: false,
-        help: false,
-        nonInteractive: true,
-        async: false,
-      }),
+      generateCommand.execute(baseConfig, baseFlags),
     ).rejects.toThrow('Missing required argument: --prompt');
   });
+
+  it('throws when width is provided without height', async () => {
+    await expect(
+      generateCommand.execute(baseConfig, { ...baseFlags, prompt: 'test', width: 1024 }),
+    ).rejects.toThrow('--width requires --height');
+  });
+
+  it('throws when height is provided without width', async () => {
+    await expect(
+      generateCommand.execute(baseConfig, { ...baseFlags, prompt: 'test', height: 1024 }),
+    ).rejects.toThrow('--height requires --width');
+  });
+
+  it('throws when width is below 512', async () => {
+    await expect(
+      generateCommand.execute(baseConfig, { ...baseFlags, prompt: 'test', width: 256, height: 256 }),
+    ).rejects.toThrow('must be between 512 and 2048');
+  });
+
+  it('throws when height is above 2048', async () => {
+    await expect(
+      generateCommand.execute(baseConfig, { ...baseFlags, prompt: 'test', width: 1024, height: 4096 }),
+    ).rejects.toThrow('must be between 512 and 2048');
+  });
+
+  it('throws when dimensions are not multiples of 8', async () => {
+    await expect(
+      generateCommand.execute(baseConfig, { ...baseFlags, prompt: 'test', width: 1025, height: 1024 }),
+    ).rejects.toThrow('must be a multiple of 8');
+  });
+
+  it('throws when --out is used with --n > 1', async () => {
+    await expect(
+      generateCommand.execute(baseConfig, { ...baseFlags, prompt: 'test', out: '/tmp/img.jpg', n: 3 }),
+    ).rejects.toThrow('--out cannot be used with --n > 1');
+  });
+
+  it('builds correct request body in dry-run', async () => {
+    let captured = '';
+    const origLog = console.log;
+    console.log = (msg: string) => { captured += msg; };
+    try {
+      await generateCommand.execute(
+        { ...baseConfig, dryRun: true, output: 'json' as const },
+        { ...baseFlags, dryRun: true, prompt: 'A cat', aspectRatio: '16:9', n: 2, seed: 42 },
+      );
+    } catch { /* dry-run may log or resolve */ }
+    console.log = origLog;
+    const parsed = JSON.parse(captured);
+    expect(parsed.request.prompt).toBe('A cat');
+    expect(parsed.request.n).toBe(2);
+    expect(parsed.request.seed).toBe(42);
+    expect(parsed.request.model).toBe('image-01');
+  });
 });

test/commands/quota/show.test.ts

@@ -1,46 +1,50 @@
 import { describe, it, expect } from 'bun:test';
 import { default as showCommand } from '../../../src/commands/quota/show';
 
+const baseConfig = {
+  apiKey: 'test-key',
+  region: 'global' as const,
+  baseUrl: 'https://api.mmx.io',
+  output: 'text' as const,
+  timeout: 10,
+  verbose: false,
+  quiet: false,
+  noColor: true,
+  yes: false,
+  dryRun: false,
+  nonInteractive: true,
+  async: false,
+};
+
+const baseFlags = {
+  quiet: false,
+  verbose: false,
+  noColor: true,
+  yes: false,
+  dryRun: false,
+  help: false,
+  nonInteractive: true,
+  async: false,
+};
+
 describe('quota show command', () => {
   it('has correct name', () => {
     expect(showCommand.name).toBe('quota show');
   });
 
   it('handles dry run', async () => {
-    const config = {
-      apiKey: 'test-key',
-      region: 'global' as const,
-      baseUrl: 'https://api.mmx.io',
-      output: 'text' as const,
-      timeout: 10,
-      verbose: false,
-      quiet: false,
-      noColor: true,
-      yes: false,
-      dryRun: true,
-      nonInteractive: true,
-      async: false,
-    };
-
-    const originalLog = console.log;
-    let output = '';
-    console.log = (msg: string) => { output += msg; };
-
+    let captured = '';
+    const origLog = console.log;
+    console.log = (msg: string) => { captured += msg; };
     try {
-      await showCommand.execute(config, {
-        quiet: false,
-        verbose: false,
-        noColor: true,
-        yes: false,
-        dryRun: true,
-        help: false,
-        nonInteractive: true,
-        async: false,
-      });
-
-      expect(output).toContain('Would fetch quota');
+      await showCommand.execute(
+        { ...baseConfig, dryRun: true },
+        { ...baseFlags, dryRun: true },
+      );
+      expect(captured).toContain('Would fetch quota');
     } finally {
-      console.log = originalLog;
+      console.log = origLog;
     }
   });
+
 });