framework/arguments/ArgumentParser.test.ts

import "reflect-metadata";

import Application from "@framework/app/Application";
import ArgumentParser from "@framework/arguments/ArgumentParser";
import { ArgumentSchema } from "@framework/arguments/ArgumentTypes";
import { InvalidArgumentError } from "@framework/arguments/InvalidArgumentError";
import NumberArgument from "@framework/arguments/NumberArgument";
import StringArgument from "@framework/arguments/StringArgument";
import { Command } from "@framework/commands/Command";
import LegacyContext from "@framework/commands/LegacyContext";
import { Message } from "discord.js";
import { beforeEach, describe, expect, it } from "vitest";
import { createApplication } from "../../mocks/application.mock";

@ArgumentSchema.Definition({
    names: ["string"],
    types: [StringArgument],
    optional: false
})
@ArgumentSchema.Definition({
    names: ["number"],
    types: [NumberArgument],
    optional: false
})
@ArgumentSchema.Options([
    {
        id: "option",
        longNames: ["option"],
        shortNames: ["o"],
        requiresValue: false,
        required: false
    },
    {
        id: "flag",
        longNames: ["flag"],
        shortNames: ["f"],
        requiresValue: true,
        required: false
    }
])
class TestCommand {
    public readonly name = "test";
    public readonly description = "Test command";

    public async execute() {
        return;
    }
}

describe("ArgumentParser", () => {
    let application: Application;
    let parser: ArgumentParser;

    beforeEach(() => {
        application = createApplication();
        parser = new ArgumentParser();
    });

    it("should parse basic arguments", async () => {
        const commandContent = "test hello 12";
        const argv = commandContent.split(/\s+/);
        const args = argv.slice(1);

        const result = await parser.parse({
            command: new TestCommand() as unknown as Command,
            context: new LegacyContext("test", commandContent, {} as Message<true>, args, argv)
        });

        expect(result).toEqual({
            value: {
                parsedArgs: {
                    string: "hello",
                    number: 12
                },
                parsedOptions: {}
            },
            errors: {}
        });
    });

    it("should parse basic arguments with options", async () => {
        const commandContent = "test -o hello -f 486 12";
        const argv = commandContent.split(/\s+/);
        const args = argv.slice(1);

        const result = await parser.parse({
            command: new TestCommand() as unknown as Command,
            context: new LegacyContext("test", commandContent, {} as Message<true>, args, argv)
        });

        expect(result).toEqual({
            value: {
                parsedArgs: {
                    string: "hello",
                    number: 12
                },
                parsedOptions: {
                    option: true,
                    flag: "486"
                }
            },
            errors: {}
        });
    });

    it("should throw an error if arguments are passed incorrectly", () => {
        const commandContent = "test hello";
        const argv = commandContent.split(/\s+/);
        const args = argv.slice(1);

        return expect(
            parser.parse({
                command: new TestCommand() as unknown as Command,
                context: new LegacyContext("test", commandContent, {} as Message<true>, args, argv),
                throwOnError: true
            })
        ).rejects.toThrowError(InvalidArgumentError);
    });
});
1	rakinar2	575	import "reflect-metadata";
2
3			import Application from "@framework/app/Application";
4			import ArgumentParser from "@framework/arguments/ArgumentParser";
5			import { ArgumentSchema } from "@framework/arguments/ArgumentTypes";
6			import { InvalidArgumentError } from "@framework/arguments/InvalidArgumentError";
7			import NumberArgument from "@framework/arguments/NumberArgument";
8			import StringArgument from "@framework/arguments/StringArgument";
9			import { Command } from "@framework/commands/Command";
10			import LegacyContext from "@framework/commands/LegacyContext";
11			import { Message } from "discord.js";
12			import { beforeEach, describe, expect, it } from "vitest";
13			import { createApplication } from "../../mocks/application.mock";
14
15			@ArgumentSchema.Definition({
16			names: ["string"],
17			types: [StringArgument],
18			optional: false
19			})
20			@ArgumentSchema.Definition({
21			names: ["number"],
22			types: [NumberArgument],
23			optional: false
24			})
25			@ArgumentSchema.Options([
26			{
27			id: "option",
28			longNames: ["option"],
29			shortNames: ["o"],
30			requiresValue: false,
31			required: false
32			},
33			{
34			id: "flag",
35			longNames: ["flag"],
36			shortNames: ["f"],
37			requiresValue: true,
38			required: false
39			}
40			])
41			class TestCommand {
42			public readonly name = "test";
43			public readonly description = "Test command";
44
45			public async execute() {
46			return;
47			}
48			}
49
50			describe("ArgumentParser", () => {
51			let application: Application;
52			let parser: ArgumentParser;
53
54			beforeEach(() => {
55			application = createApplication();
56			parser = new ArgumentParser();
57			});
58
59			it("should parse basic arguments", async () => {
60			const commandContent = "test hello 12";
61			const argv = commandContent.split(/\s+/);
62			const args = argv.slice(1);
63
64			const result = await parser.parse({
65			command: new TestCommand() as unknown as Command,
66			context: new LegacyContext("test", commandContent, {} as Message<true>, args, argv)
67			});
68
69			expect(result).toEqual({
70			value: {
71			parsedArgs: {
72			string: "hello",
73			number: 12
74			},
75			parsedOptions: {}
76			},
77			errors: {}
78			});
79			});
80
81			it("should parse basic arguments with options", async () => {
82			const commandContent = "test -o hello -f 486 12";
83			const argv = commandContent.split(/\s+/);
84			const args = argv.slice(1);
85
86			const result = await parser.parse({
87			command: new TestCommand() as unknown as Command,
88			context: new LegacyContext("test", commandContent, {} as Message<true>, args, argv)
89			});
90
91			expect(result).toEqual({
92			value: {
93			parsedArgs: {
94			string: "hello",
95			number: 12
96			},
97			parsedOptions: {
98			option: true,
99			flag: "486"
100			}
101			},
102			errors: {}
103			});
104			});
105
106			it("should throw an error if arguments are passed incorrectly", () => {
107			const commandContent = "test hello";
108			const argv = commandContent.split(/\s+/);
109			const args = argv.slice(1);
110
111			return expect(
112			parser.parse({
113			command: new TestCommand() as unknown as Command,
114			context: new LegacyContext("test", commandContent, {} as Message<true>, args, argv),
115			throwOnError: true
116			})
117			).rejects.toThrowError(InvalidArgumentError);
118			});
119			});