Merge pull request #151 from NianJiuZst/test/missing-command-tests

test: add unit tests for music cover, speech voices, and config export-schema

Author: RyanLee-Dev

test/commands/config/export-schema.test.ts

@@ -0,0 +1,107 @@
+import { describe, it, expect } from 'bun:test';
+import { generateToolSchema } from '../../../src/utils/schema';
+import { registry } from '../../../src/registry';
+
+type JsonSchema = Record<string, unknown>;
+type ToolSchema = { name: string; description?: string; input_schema: JsonSchema };
+
+function getSchema(cmdName: string): ToolSchema {
+  const { command } = registry.resolve(cmdName.split(' '));
+  return generateToolSchema(command) as unknown as ToolSchema;
+}
+
+function is(input: unknown): JsonSchema {
+  return input as JsonSchema;
+}
+
+describe('generateToolSchema', () => {
+  it('generates schema for text chat command', () => {
+    const schema = getSchema('text chat');
+
+    expect(schema.name).toBe('mmx_text_chat');
+    expect(schema.description).toBeDefined();
+    expect(schema.input_schema).toBeDefined();
+    expect(schema.input_schema.type).toBe('object');
+    expect(schema.input_schema.properties).toBeDefined();
+  });
+
+  it('includes required flag properties', () => {
+    const schema = getSchema('image generate');
+
+    const ischema = schema.input_schema;
+    const props = is(ischema.properties);
+    expect(props.prompt).toBeDefined();
+    expect(is(props.prompt).type).toBe('string');
+    expect(ischema.required).toContain('prompt');
+  });
+
+  it('infers number type from numeric flags', () => {
+    const schema = getSchema('text chat');
+
+    const props = is(schema.input_schema.properties);
+    const maxTokens = Object.entries(props).find(([key]) => key === 'maxTokens');
+    expect(maxTokens).toBeDefined();
+    expect(is(maxTokens![1]!).type).toBe('number');
+  });
+
+  it('infers boolean type for flagless options', () => {
+    const schema = getSchema('text chat');
+
+    const props = is(schema.input_schema.properties);
+    expect(props.stream).toBeDefined();
+    expect(is(props.stream).type).toBe('boolean');
+  });
+
+  it('infers array type for repeatable options', () => {
+    const schema = getSchema('text chat');
+
+    const props = is(schema.input_schema.properties);
+    expect(props.message).toBeDefined();
+    expect(is(props.message).type).toBe('array');
+  });
+
+  it('name uses underscore-separated path', () => {
+    const schema = getSchema('speech synthesize');
+
+    expect(schema.name).toBe('mmx_speech_synthesize');
+  });
+});
+
+describe('registry getAllCommands filtering', () => {
+  it('returns all registered commands', () => {
+    const commands = registry.getAllCommands();
+    expect(commands.length).toBeGreaterThan(10);
+    // Should contain real commands
+    const names = commands.map(c => c.name);
+    expect(names).toContain('text chat');
+    expect(names).toContain('image generate');
+    expect(names).toContain('speech synthesize');
+  });
+
+  it('filters out auth, config, update prefixes', () => {
+    const SKIP = ['auth ', 'config ', 'update'];
+    const commands = registry.getAllCommands();
+    const filtered = commands.filter(c => !SKIP.some(p => c.name.startsWith(p)));
+
+    const names = filtered.map(c => c.name);
+    expect(names.every(n => !n.startsWith('auth '))).toBe(true);
+    expect(names.every(n => !n.startsWith('config '))).toBe(true);
+    // Real commands remain
+    expect(names.some(n => n === 'text chat')).toBe(true);
+    expect(names.some(n => n === 'image generate')).toBe(true);
+    expect(names.some(n => n === 'music generate')).toBe(true);
+  });
+
+  it('every filtered command generates valid schema', () => {
+    const SKIP = ['auth ', 'config ', 'update'];
+    const commands = registry.getAllCommands();
+    const filtered = commands.filter(c => !SKIP.some(p => c.name.startsWith(p)));
+
+    for (const cmd of filtered) {
+      const schema = generateToolSchema(cmd) as unknown as ToolSchema;
+      expect(schema.name).toMatch(/^mmx_\w/);
+      expect(schema.input_schema.type).toBe('object');
+      expect(typeof schema.description).toBe('string');
+    }
+  });
+});

test/commands/music/cover.test.ts

@@ -0,0 +1,205 @@
+import { describe, it, expect } from 'bun:test';
+import { default as coverCommand } from '../../../src/commands/music/cover';
+
+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('music cover command', () => {
+  it('has correct name', () => {
+    expect(coverCommand.name).toBe('music cover');
+  });
+
+  it('requires --prompt', async () => {
+    await expect(
+      coverCommand.execute(baseConfig, baseFlags),
+    ).rejects.toThrow('--prompt is required');
+  });
+
+  it('requires either --audio or --audio-file', async () => {
+    await expect(
+      coverCommand.execute(
+        baseConfig,
+        { ...baseFlags, prompt: 'Indie folk cover' },
+      ),
+    ).rejects.toThrow('One of --audio <url> or --audio-file <path> is required');
+  });
+
+  it('rejects using both --audio and --audio-file', async () => {
+    await expect(
+      coverCommand.execute(
+        baseConfig,
+        { ...baseFlags, prompt: 'Indie folk', audio: 'https://example.com/song.mp3', audioFile: '/tmp/ref.mp3' },
+      ),
+    ).rejects.toThrow('Use either --audio or --audio-file, not both');
+  });
+
+  it('builds correct request body in dry-run with --audio', async () => {
+    let captured = '';
+    const origLog = console.log;
+    console.log = (msg: string) => { captured += msg; };
+
+    try {
+      await coverCommand.execute(
+        { ...baseConfig, dryRun: true, output: 'json' as const },
+        {
+          ...baseFlags,
+          dryRun: true,
+          prompt: 'Jazz cover',
+          audio: 'https://example.com/ref.mp3',
+        },
+      );
+    } catch {
+      // dry-run may resolve or reject
+    }
+
+    console.log = origLog;
+    const parsed = JSON.parse(captured);
+    expect(parsed.request.model).toMatch(/^music-cover/);
+    expect(parsed.request.prompt).toBe('Jazz cover');
+    expect(parsed.request.audio_url).toBe('https://example.com/ref.mp3');
+    expect(parsed.request.output_format).toBe('hex');
+  });
+
+  it('accepts optional --lyrics', async () => {
+    let captured = '';
+    const origLog = console.log;
+    console.log = (msg: string) => { captured += msg; };
+
+    try {
+      await coverCommand.execute(
+        { ...baseConfig, dryRun: true, output: 'json' as const },
+        {
+          ...baseFlags,
+          dryRun: true,
+          prompt: 'Pop cover',
+          audio: 'https://example.com/ref.mp3',
+          lyrics: 'New lyrics here',
+        },
+      );
+    } catch {
+      // dry-run may resolve or reject
+    }
+
+    console.log = origLog;
+    const parsed = JSON.parse(captured);
+    expect(parsed.request.lyrics).toBe('New lyrics here');
+  });
+
+  it('accepts optional --seed', async () => {
+    let captured = '';
+    const origLog = console.log;
+    console.log = (msg: string) => { captured += msg; };
+
+    try {
+      await coverCommand.execute(
+        { ...baseConfig, dryRun: true, output: 'json' as const },
+        {
+          ...baseFlags,
+          dryRun: true,
+          prompt: 'Rock cover',
+          audio: 'https://example.com/ref.mp3',
+          seed: 42,
+        },
+      );
+    } catch {
+      // dry-run may resolve or reject
+    }
+
+    console.log = origLog;
+    const parsed = JSON.parse(captured);
+    expect(parsed.request.seed).toBe(42);
+  });
+
+  it('rejects invalid model', async () => {
+    await expect(
+      coverCommand.execute(
+        { ...baseConfig, dryRun: true },
+        {
+          ...baseFlags,
+          prompt: 'Folk cover',
+          audio: 'https://example.com/ref.mp3',
+          model: 'music-2.6',
+        },
+      ),
+    ).rejects.toThrow('Invalid model');
+  });
+
+  it('rejects invalid audio format', async () => {
+    await expect(
+      coverCommand.execute(
+        { ...baseConfig, dryRun: true },
+        {
+          ...baseFlags,
+          prompt: 'Folk cover',
+          audio: 'https://example.com/ref.mp3',
+          format: 'opus',
+        },
+      ),
+    ).rejects.toThrow('Invalid audio format');
+  });
+
+  it.each(['mp3', 'wav', 'pcm'])(
+    'accepts %s format in dry-run',
+    async (fmt) => {
+      let captured = '';
+      const origLog = console.log;
+      console.log = (msg: string) => { captured += msg; };
+      try {
+        await coverCommand.execute(
+          { ...baseConfig, dryRun: true, output: 'json' as const },
+          {
+            ...baseFlags,
+            dryRun: true,
+            prompt: 'Folk cover',
+            audio: 'https://example.com/ref.mp3',
+            format: fmt,
+          },
+        );
+        const parsed = JSON.parse(captured);
+        expect(parsed.request.audio_setting.format).toBe(fmt);
+      } finally {
+        console.log = origLog;
+      }
+    },
+  );
+
+  it('has expected options', () => {
+    const flags = coverCommand.options?.map(o => o.flag) ?? [];
+    expect(flags.some(f => f.startsWith('--audio'))).toBe(true);
+    expect(flags.some(f => f.startsWith('--audio-file'))).toBe(true);
+    expect(flags.some(f => f.startsWith('--lyrics'))).toBe(true);
+    expect(flags.some(f => f.startsWith('--seed'))).toBe(true);
+    expect(flags.some(f => f.startsWith('--format'))).toBe(true);
+    expect(flags.some(f => f.startsWith('--out'))).toBe(true);
+  });
+
+  it('has examples with --audio and --audio-file usage', () => {
+    const examples = coverCommand.examples ?? [];
+    const joined = examples.join(' ');
+    expect(joined).toContain('--audio');
+    expect(joined).toContain('--audio-file');
+  });
+});