♻️ refactor(cli): validate startup arguments

2026-07-11 18:07:22 +08:00
parent 9416d44d3d
commit 3642aa8b5b
7 changed files with 368 additions and 106 deletions
@@ -0,0 +1,131 @@
+module;
+
+export module lsp.test.args_parser;
+
+import spdlog;
+import std;
+
+import lsp.utils.args_parser;
+
+namespace
+{
+    void Expect(bool condition, std::string_view message)
+    {
+        if (!condition)
+            throw std::runtime_error(std::string(message));
+    }
+
+    auto Parse(std::initializer_list<std::string_view> arguments)
+    {
+        std::vector<std::string> storage{ "tsl-server" };
+        storage.reserve(arguments.size() + 1);
+        for (auto argument : arguments)
+            storage.emplace_back(argument);
+
+        std::vector<char*> argv;
+        argv.reserve(storage.size());
+        for (auto& argument : storage)
+            argv.push_back(argument.data());
+
+        return lsp::utils::ParseArgs(static_cast<int>(argv.size()), argv.data());
+    }
+
+    void ExpectError(std::initializer_list<std::string_view> arguments,
+                     std::string_view fragment)
+    {
+        auto result = Parse(arguments);
+        Expect(!result.has_value(), "arguments should be rejected");
+        Expect(result.error().find(fragment) != std::string::npos,
+               "error should identify the invalid argument");
+    }
+}
+
+export int Run()
+{
+    int failures = 0;
+    auto RunCase = [&failures](std::string_view name, auto test) {
+        try
+        {
+            test();
+            std::cout << "[PASS] " << name << '\n';
+        }
+        catch (const std::exception& error)
+        {
+            ++failures;
+            std::cout << "[FAIL] " << name << ": " << error.what() << '\n';
+        }
+    };
+
+    RunCase("defaults", [] {
+        auto result = Parse({});
+        Expect(result.has_value(), "default arguments should parse");
+        Expect(result->action == lsp::utils::ParseAction::kRun,
+               "default action should run");
+        Expect(result->config.thread_count == 4, "default thread count should be 4");
+        Expect(result->config.log_level == spdlog::level::info,
+               "default log level should be info");
+    });
+
+    RunCase("valid values and last occurrence", [] {
+        auto result = Parse({ "--threads=8", "--threads=16", "--log=debug", "--log-file=server.log", "--interpreter=/opt/tsl" });
+        Expect(result.has_value(), "valid arguments should parse");
+        Expect(result->config.thread_count == 16, "last thread count should win");
+        Expect(result->config.log_level == spdlog::level::debug,
+               "debug log level should parse");
+        Expect(result->config.log_file == "server.log", "log file should parse");
+        Expect(result->config.interpreter_path == "/opt/tsl",
+               "interpreter path should parse");
+    });
+
+    RunCase("all log levels", [] {
+        const std::array levels{
+            std::pair{ "trace", spdlog::level::trace },
+            std::pair{ "debug", spdlog::level::debug },
+            std::pair{ "info", spdlog::level::info },
+            std::pair{ "warn", spdlog::level::warn },
+            std::pair{ "error", spdlog::level::err },
+            std::pair{ "off", spdlog::level::off },
+        };
+        for (const auto& [name, level] : levels)
+        {
+            const std::string argument = std::string("--log=") + name;
+            auto result = Parse({ argument });
+            Expect(result.has_value(), "known log level should parse");
+            Expect(result->config.log_level == level, "log level should match");
+        }
+    });
+
+    RunCase("help takes precedence", [] {
+        auto result = Parse({ "--unknown", "--help", "--threads=bad" });
+        Expect(result.has_value(), "help should bypass other validation");
+        Expect(result->action == lsp::utils::ParseAction::kShowHelp,
+               "help action should be returned");
+    });
+
+    RunCase("thread validation", [] {
+        Expect(Parse({ "--threads=1" }).has_value(), "one thread should parse");
+        Expect(Parse({ "--threads=256" }).has_value(), "256 threads should parse");
+        for (auto argument : { "--threads=", "--threads=0", "--threads=-1", "--threads=257", "--threads=12junk", "--threads=18446744073709551616" })
+            ExpectError({ argument }, "--threads");
+    });
+
+    RunCase("other invalid values", [] {
+        for (auto argument : { "--log=verbose", "--log-file=", "--interpreter=", "--log-stdout", "--log-stderr", "--use-stdio", "--unknown" })
+            ExpectError({ argument }, "--");
+    });
+
+    RunCase("help formatting", [] {
+        std::ostringstream output;
+        lsp::utils::PrintHelp(output, "tsl-server");
+        const auto text = output.str();
+        Expect(text.contains("Usage: tsl-server [options]\n\nOptions:\n"),
+               "help should contain physical line breaks");
+        Expect(!text.contains("\\n"), "help should not contain escaped newline text");
+        Expect(!text.contains("--log-stdout"), "removed stdout flag should be absent");
+        Expect(!text.contains("--log-stderr"), "removed stderr flag should be absent");
+        Expect(!text.contains("--use-stdio"), "removed stdio alias should be absent");
+    });
+
+    std::cout << "Failures: " << failures << '\n';
+    return failures == 0 ? 0 : 1;
+}