1import {
2  assertUnknownArgs,
3  resolveStringOrBooleanArgsAsync,
4  assertDuplicateArgs,
5  collapseAliases,
6  _resolveStringOrBooleanArgs,
7} from '../resolveArgs';
8
9describe(collapseAliases, () => {
10  it(`will collapse aliases into arguments`, () => {
11    const arg = {
12      '--basic': Boolean,
13      '--help': Boolean,
14      '-h': '--help',
15    };
16    const args = ['--basic', '-h'];
17    const actual = collapseAliases(arg, args);
18    expect(actual).toEqual(['--basic', '--help']);
19  });
20});
21
22describe(_resolveStringOrBooleanArgs, () => {
23  it(`resolves string or boolean arguments to boolean`, () => {
24    expect(
25      _resolveStringOrBooleanArgs(
26        {
27          '--basic': Boolean,
28          // This will be omitted since we should handle collapsing aliases earlier.
29          '-b': 'foobar',
30        },
31        ['--basic']
32      )
33    ).toEqual({
34      args: { '--basic': true },
35      projectRoot: '.',
36    });
37  });
38  it(`resolves to string`, () => {
39    expect(_resolveStringOrBooleanArgs({ '--basic': Boolean }, ['--basic', 'foobar'])).toEqual({
40      args: { '--basic': 'foobar' },
41      // foobar will be used as the string value for basic and not as the project root
42      projectRoot: '.',
43    });
44  });
45  it(`resolves to string with custom project root`, () => {
46    expect(
47      _resolveStringOrBooleanArgs({ '--basic': Boolean }, ['--basic', 'foobar', 'root'])
48    ).toEqual({
49      args: { '--basic': 'foobar' },
50      projectRoot: 'root',
51    });
52  });
53  it(`asserts invalid arguments`, () => {
54    expect(() =>
55      _resolveStringOrBooleanArgs({ '--basic': Boolean }, ['foobar', 'root', '--basic'])
56    ).toThrow(/Unknown argument: root/);
57  });
58});
59
60describe(assertUnknownArgs, () => {
61  it(`asserts unknown arguments`, () => {
62    expect(() => assertUnknownArgs({}, ['--foo', '--bar'])).toThrowError(
63      `Unknown arguments: --foo, --bar`
64    );
65  });
66  it(`does not throw when there are no unknown arguments`, () => {
67    expect(() =>
68      assertUnknownArgs(
69        {
70          '--foo': Boolean,
71          '--bar': Boolean,
72        },
73        ['--foo', '--bar']
74      )
75    ).not.toThrow();
76  });
77});
78
79describe(resolveStringOrBooleanArgsAsync, () => {
80  it(`parses complex arguments`, async () => {
81    await expect(
82      resolveStringOrBooleanArgsAsync(
83        ['--no-bundler', '--scheme', '-d', 'my-device', 'custom-root'],
84        {
85          '--no-bundler': Boolean,
86        },
87        {
88          '--scheme': Boolean,
89          '--device': Boolean,
90          '-d': '--device',
91        }
92      )
93    ).resolves.toEqual({
94      args: {
95        '--device': 'my-device',
96        '--no-bundler': true,
97        '--scheme': true,
98      },
99      projectRoot: 'custom-root',
100    });
101  });
102});
103
104describe(assertDuplicateArgs, () => {
105  it(`does not assert`, () => {
106    assertDuplicateArgs([], []);
107    assertDuplicateArgs(['--foo', '--bar'], [['--device', '-d']]);
108  });
109  it(`asserts duplicate arguments`, () => {
110    expect(() =>
111      assertDuplicateArgs(['--device', '--bar', '--device'], [['--device', '-d']])
112    ).toThrowErrorMatchingInlineSnapshot(`"Can only provide one instance of --device or -d"`);
113  });
114});
115