chore(test): improve coverage

Author: boneskull

test/opt.test.ts

@@ -257,3 +257,100 @@ describe('legacy opt positional builders', () => {
     });
   });
 });
+
+describe('callable parser merging', () => {
+  it('opt.options() as callable merges with existing parser', () => {
+    // First create a parser with positionals
+    const posParser = pos.positionals(
+      pos.string({ name: 'input', required: true }),
+    );
+
+    // Use opt.options as callable to merge in options
+    const merged = opt.options({ verbose: opt.boolean() })(posParser);
+
+    expect(merged.__brand, 'to be', 'Parser');
+    expect(merged.__optionsSchema, 'to satisfy', {
+      verbose: { type: 'boolean' },
+    });
+    expect(merged.__positionalsSchema, 'to satisfy', [
+      { name: 'input', type: 'string' },
+    ]);
+  });
+
+  it('pos.positionals() as callable merges with existing parser', () => {
+    // First create a parser with options
+    const optParser = opt.options({ verbose: opt.boolean() });
+
+    // Use pos.positionals as callable to merge in positionals
+    const merged = pos.positionals(
+      pos.string({ name: 'file', required: true }),
+    )(optParser);
+
+    expect(merged.__brand, 'to be', 'Parser');
+    expect(merged.__optionsSchema, 'to satisfy', {
+      verbose: { type: 'boolean' },
+    });
+    expect(merged.__positionalsSchema, 'to satisfy', [
+      { name: 'file', type: 'string' },
+    ]);
+  });
+
+  it('opt.options() preserves transforms from incoming parser', async () => {
+    const { map } = await import('../src/bargs.js');
+
+    // Create a parser with a transform
+    const parserWithTransform = map(
+      pos.positionals(pos.string({ name: 'input', required: true })),
+      ({ positionals, values }) => ({
+        positionals: [positionals[0].toUpperCase()] as const,
+        values,
+      }),
+    );
+
+    // Merge with options - should preserve the transform
+    const merged = opt.options({ verbose: opt.boolean() })(parserWithTransform);
+
+    // The __transform should be preserved
+    const withTransform = merged as typeof merged & {
+      __transform?: (r: unknown) => unknown;
+    };
+    expect(withTransform.__transform, 'to be a', 'function');
+  });
+
+  it('pos.positionals() preserves transforms from incoming parser', async () => {
+    const { map } = await import('../src/bargs.js');
+
+    // Create a parser with a transform
+    const parserWithTransform = map(
+      opt.options({ count: opt.number({ default: 1 }) }),
+      ({ positionals, values }) => ({
+        positionals,
+        values: { ...values, doubled: values.count * 2 },
+      }),
+    );
+
+    // Merge with positionals - should preserve the transform
+    const merged = pos.positionals(pos.string({ name: 'file' }))(
+      parserWithTransform,
+    );
+
+    // The __transform should be preserved
+    const withTransform = merged as typeof merged & {
+      __transform?: (r: unknown) => unknown;
+    };
+    expect(withTransform.__transform, 'to be a', 'function');
+  });
+
+  it('validates alias conflicts when merging', () => {
+    const p1 = opt.options({ verbose: opt.boolean({ aliases: ['v'] }) });
+
+    expect(
+      () =>
+        opt.options({ version: opt.string({ aliases: ['v'] }) })(
+          p1 as ReturnType<typeof opt.options>,
+        ),
+      'to throw',
+      /Alias conflict.*-v/,
+    );
+  });
+});

test/parser-commands.test.ts

@@ -1,15 +1,195 @@
 /**
  * Tests for command parsing.
  *
- * TODO: Rewrite for new combinator API
+ * These tests focus on command dispatching and parsing behaviors complementary
+ * to the tests in bargs.test.ts.
  */
+import { expect, expectAsync } from 'bupkis';
 import { describe, it } from 'node:test';
 
+import { bargs, handle } from '../src/bargs.js';
+import { opt, pos } from '../src/opt.js';
+
 describe('command parsing', () => {
-  it.todo('parses a command with options');
-  it.todo('parses command positionals');
-  it.todo('calls command handler');
-  it.todo('uses defaultCommand when no command given');
-  it.todo('throws on unknown command');
-  it.todo('merges global and command options');
+  it('parses a command with options', async () => {
+    let result: unknown;
+
+    const cli = bargs('test-cli').command(
+      'greet',
+      opt.options({
+        loud: opt.boolean({ default: false }),
+        name: opt.string({ default: 'world' }),
+      }),
+      ({ values }) => {
+        result = values;
+      },
+    );
+
+    await cli.parseAsync(['greet', '--name', 'Alice', '--loud']);
+
+    expect(result, 'to satisfy', {
+      loud: true,
+      name: 'Alice',
+    });
+  });
+
+  it('parses command positionals', async () => {
+    let result: unknown;
+
+    const cli = bargs('test-cli').command(
+      'greet',
+      pos.positionals(
+        pos.string({ name: 'name', required: true }),
+        pos.number({ default: 1, name: 'times' }),
+      ),
+      ({ positionals }) => {
+        result = positionals;
+      },
+    );
+
+    await cli.parseAsync(['greet', 'Alice', '3']);
+
+    expect(result, 'to satisfy', ['Alice', 3]);
+  });
+
+  it('calls command handler', async () => {
+    let handlerCalled = false;
+    let receivedValues: unknown;
+    let receivedPositionals: unknown;
+
+    const cli = bargs('test-cli').command(
+      'echo',
+      handle(
+        pos.positionals(pos.string({ name: 'message', required: true })),
+        ({ positionals, values }) => {
+          handlerCalled = true;
+          receivedValues = values;
+          receivedPositionals = positionals;
+        },
+      ),
+    );
+
+    await cli.parseAsync(['echo', 'Hello!']);
+
+    expect(handlerCalled, 'to be', true);
+    expect(receivedPositionals, 'to satisfy', ['Hello!']);
+    expect(receivedValues, 'to satisfy', {});
+  });
+
+  it('uses defaultCommand when no command given', async () => {
+    let result: unknown;
+
+    const cli = bargs('test-cli')
+      .command('run', opt.options({ verbose: opt.boolean() }), ({ values }) => {
+        result = { command: 'run', values };
+      })
+      .command('build', opt.options({}), () => {
+        result = { command: 'build' };
+      })
+      .defaultCommand('run');
+
+    await cli.parseAsync(['--verbose']);
+
+    expect(result, 'to satisfy', {
+      command: 'run',
+      values: { verbose: true },
+    });
+  });
+
+  it('throws on unknown command', async () => {
+    const cli = bargs('test-cli')
+      .command(
+        'add',
+        handle(opt.options({}), () => {}),
+      )
+      .command(
+        'remove',
+        handle(opt.options({}), () => {}),
+      );
+
+    await expectAsync(
+      cli.parseAsync(['unknown']),
+      'to reject with error satisfying',
+      /Unknown command: unknown/,
+    );
+  });
+
+  it('merges global and command options', async () => {
+    let result: unknown;
+
+    const cli = bargs('test-cli')
+      .globals(
+        opt.options({
+          config: opt.string({ default: './config.json' }),
+          verbose: opt.boolean({ default: false }),
+        }),
+      )
+      .command(
+        'deploy',
+        opt.options({
+          env: opt.enum(['dev', 'staging', 'prod'], { default: 'dev' }),
+          force: opt.boolean({ default: false }),
+        }),
+        ({ values }) => {
+          result = values;
+        },
+      );
+
+    await cli.parseAsync(['deploy', '--verbose', '--env', 'prod', '--force']);
+
+    expect(result, 'to satisfy', {
+      config: './config.json',
+      env: 'prod',
+      force: true,
+      verbose: true,
+    });
+  });
+
+  it('parses command with mixed options and positionals', async () => {
+    let result: unknown;
+
+    const cli = bargs('test-cli').command(
+      'copy',
+      handle(
+        pos.positionals(
+          pos.string({ name: 'source', required: true }),
+          pos.string({ name: 'dest', required: true }),
+        )(
+          opt.options({
+            force: opt.boolean({ aliases: ['f'] }),
+            recursive: opt.boolean({ aliases: ['r'] }),
+          }),
+        ),
+        ({ positionals, values }) => {
+          result = { positionals, values };
+        },
+      ),
+    );
+
+    await cli.parseAsync(['copy', '-rf', 'src/', 'dst/']);
+
+    expect(result, 'to satisfy', {
+      positionals: ['src/', 'dst/'],
+      values: { force: true, recursive: true },
+    });
+  });
+
+  it('passes positionals through to default command', async () => {
+    let result: unknown;
+
+    const cli = bargs('test-cli')
+      .command(
+        'run',
+        pos.positionals(pos.variadic('string', { name: 'files' })),
+        ({ positionals }) => {
+          result = positionals;
+        },
+      )
+      .defaultCommand('run');
+
+    // When no command matches, positionals go to default command
+    await cli.parseAsync(['file1.js', 'file2.js', 'file3.js']);
+
+    expect(result, 'to satisfy', [['file1.js', 'file2.js', 'file3.js']]);
+  });
 });