Crafter.Review/tests/Config/main.cpp

// SPDX-License-Identifier: AGPL-3.0-only
// SPDX-FileCopyrightText: Copyright (C) 2026 Catcrafts®

// The consumer config: the defaults, the merge, unknown keys, validation,
// the lenses (run, environment), authors, the login fixture, the example.

#include <stdlib.h>
import std;
import Crafter.Review;
namespace fs = std::filesystem;
using namespace Crafter::Review;

namespace {
    std::int32_t Failures = 0;

    void Check(std::string_view name, bool cond, std::string_view detail = {}) {
        std::println("{}{}{}", cond ? "  ok   " : "  FAIL ", name, !cond && !detail.empty() ? std::format("  ({})", detail) : std::string());
        if (!cond) ++Failures;
    }

    bool Any(const std::vector<std::string>& problems, std::string_view part) {
        return std::ranges::any_of(problems, [&](const std::string& p) { return p.contains(part); });
    }

    std::string Show(const std::vector<std::string>& problems) {
        Json out = Json::array();
        for (const std::string& p : problems) out.push_back(p);
        return Dyn::ReprValue(out);
    }
}

int main() {
    std::println("config: defaults, merge, unknown keys, validation, lenses (run, environment), authors, login fixture, the example");
    // A git call of a test reads no global config: this machine's signs
    // every commit with the owner's key.
    setenv("GIT_CONFIG_GLOBAL", "/dev/null", 1);
    setenv("GIT_CONFIG_SYSTEM", "/dev/null", 1);
    SetHome(fs::current_path());
    const std::string fn(Plan::FunctionalLens);
    const fs::path td = fs::temp_directory_path() / std::format("crafter-review-config-{}", Platform::PublishedPid());
    fs::remove_all(td);
    fs::create_directories(td);
    auto load = [&] { return Config::Load(td); };
    Config::Loaded loaded = load();
    Check("no file: the defaults, no problem, _path None", loaded.problems.empty() && loaded.config.at("aiTrailers") == "forbid"
          && loaded.config.at("functional").at("appUrl") == "http://localhost:8080" && loaded.config.at("_path").is_null());
    fs::create_directories(td / ".review-gates");
    const fs::path p = td / ".review-gates" / "config.json";
    auto put = [&](const Json& value) { std::ofstream(p, std::ios::binary) << DumpSpaced(value); };
    auto bad = [&](const Json& value) {
        put(value);
        return load().problems;
    };
    put({{"base", "origin/dev"}, {"aiTrailers", "allow"}, {"allowDirty", {"supabase/config.toml"}},
         {"functional", {{"exclude", {"**/*.test.ts"}}, {"readyPath", "/health"}, {"extraTools", {"Bash(redis-cli:*)", "mcp__x__y"}}}}});
    loaded = load();
    Check("the file merges over the defaults, nested too", loaded.problems.empty() && loaded.config.at("base") == "origin/dev" && loaded.config.at("aiTrailers") == "allow"
          && loaded.config.at("functional").at("readyPath") == "/health" && loaded.config.at("functional").at("appUrl") == "http://localhost:8080" && loaded.config.at("_path") == p.string(),
          Show(loaded.problems));
    Check("rangeFrom 'base' without a base branch is a problem; 'sideways' is one too", Any(bad({{"rangeFrom", "base"}}), "needs a base")
          && Any(bad({{"rangeFrom", "sideways"}, {"base", "origin/dev"}}), "rangeFrom must be"));
    std::vector<std::string> problems = bad({{"bogus", 1}, {"functional", {{"nope", 2}, {"appUrl", "ftp://x"}}}, {"aiTrailers", "maybe"}, {"authors", {"nomail"}}});
    Check("unknown keys and bad values are each a problem", problems.size() == 5 && Any(problems, "bogus") && Any(problems, "functional.nope") && Any(problems, "appUrl")
          && Any(problems, "aiTrailers") && Any(problems, "authors"), Show(problems));
    problems = bad({{"functional", {{"extraTools", {"rm -rf /"}}, {"mcp", {{"args", "x"}}}}}});
    Check("extraTools must be Bash(<prefix>:*) or mcp__...; mcp.args a list", problems.size() == 2, Show(problems));
    std::ofstream(p, std::ios::binary) << "{not json";
    Check("not JSON -> one problem", load().problems.size() == 1);
    Check("--config to a missing file is a problem", Any(Config::Load(td, td / "none.json").problems, "no such file"));
    put(Json::object());
    loaded = load();
    bool allRun = true;
    for (const Json& entry : loaded.config.at("lenses")) allRun = allRun && entry.at("run") == true;
    bool defaultsMatch = true;
    std::set<std::string> names;
    for (const Plan::Lens& lens : Plan::Lenses) {
        names.insert(Plan::LensName(lens.file));
        defaultsMatch = defaultsMatch && Config::Defaults().at("lenses").at(Plan::LensName(lens.file)).at("environment") == lens.env;
    }
    const Json defaults = Config::Defaults();
    std::set<std::string> defaultNames;
    for (auto it = defaults.at("lenses").begin(); it != defaults.at("lenses").end(); ++it) defaultNames.insert(it.key());
    const Json environments = {{"repo-better-solution.md", "none"}, {fn, "browser"}, {"repo-bug-prover.md", "none"}, {"repo-security.md", "none"}};
    Check("lenses: the defaults run all four with none/browser/none/none - plan.LENSES' env; the table names every lens of plan.LENSES", loaded.problems.empty() && allRun
          && Config::LensesOff(loaded.config).empty() && Dyn::Equal(Config::Environments(loaded.config), environments) && defaultNames == names && defaultsMatch, Show(loaded.problems));
    put({{"lenses", {{"repo-functional", {{"run", false}}}, {"repo-bug-prover", {{"environment", "browser"}}}}}});
    loaded = load();
    Check("lenses: run=false merges and lists the lens off in gate order; a static lens may take the browser", loaded.problems.empty()
          && Config::LensesOff(loaded.config) == std::vector<std::string>{fn} && Config::Environments(loaded.config).at("repo-bug-prover.md") == "browser"
          && loaded.config.at("lenses").at("repo-functional").at("environment") == "browser", Show(loaded.problems));
    problems = bad({{"lenses", {{"nope", {{"run", true}}}, {"repo-better-solution", {{"run", "yes"}, {"environment", "http"}}}}}});
    Check("lenses: an unknown lens is an unknown key; run must be a bool; environment must be one of none, browser, supabase, browser+supabase", problems.size() == 3
          && Any(problems, "lenses.nope") && Any(problems, "run must be") && Any(problems, "one of none, browser, supabase, browser+supabase"), Show(problems));
    problems = bad({{"lenses", {{"repo-functional", {{"environment", "none"}}}}}});
    Check("the functional lens running with no application under test is a problem; off with none is fine; an unknown environment is reported once",
          problems.size() == 1 && problems[0].contains("empirical") && bad({{"lenses", {{"repo-functional", {{"run", false}, {"environment", "none"}}}}}}).empty()
          && bad({{"lenses", {{"repo-functional", {{"environment", "http"}}}}}}).size() == 1, Show(problems));
    problems = bad({{"lenses", {{"repo-functional", {{"environment", "supabase"}}}}}});
    Check("the database alone is no application under test for the functional lens; browser+supabase is; a static lens may take either, or the database alone",
          problems.size() == 1 && problems[0].contains("empirical") && problems[0].contains("browser, browser+supabase")
          && bad({{"lenses", {{"repo-functional", {{"environment", "browser+supabase"}}}, {"repo-bug-prover", {{"environment", "supabase"}}},
                              {"repo-better-solution", {{"environment", "browser+supabase"}}}}}}).empty(), Show(problems));
    loaded = load();
    Check("supabase: the defaults are the local stack's Postgres (54322), no start/stop, no notes",
          Dyn::Equal(loaded.config.at("supabase"), {{"dbUrl", "postgresql://postgres:postgres@127.0.0.1:54322/postgres"}, {"start", nullptr}, {"stop", nullptr}, {"notes", ""}}));
    problems = bad({{"supabase", {{"dbUrl", "postgresql://postgres:secret@db.abcdefgh.supabase.co:5432/postgres"}}}});
    Check("supabase.dbUrl: a hosted database is refused (this machine only), and the message does not echo the password", problems.size() == 1
          && problems[0].contains("not this machine") && !problems[0].contains("secret"), Show(problems));
    Check("supabase.dbUrl: http:// is no database URL; localhost and ::1 are this machine; start/stop must be command lines; an unknown key is reported",
          Any(bad({{"supabase", {{"dbUrl", "http://127.0.0.1:54321"}}}}), "postgres://") && bad({{"supabase", {{"dbUrl", "postgres://u:p@localhost:6543/x"}}}}).empty()
          && bad({{"supabase", {{"dbUrl", "postgresql://u@[::1]:5432/x"}}}}).empty() && Any(bad({{"supabase", {{"start", {"bash", "x"}}}}}), "supabase.start")
          && Any(bad({{"supabase", {{"nope", 1}}}}), "supabase.nope"));
    Check("functional.appUrl is checked only while a lens that runs drives the application (plan.ENVIRONMENTS item 4)",
          Any(bad({{"functional", {{"appUrl", "ftp://x"}}}}), "appUrl")
          && bad({{"functional", {{"appUrl", "ftp://x"}}}, {"lenses", {{"repo-functional", {{"run", false}}}, {"repo-bug-prover", {{"environment", "supabase"}}}}}}).empty()
          && Any(bad({{"functional", {{"appUrl", "ftp://x"}}}, {"lenses", {{"repo-functional", {{"run", false}}}, {"repo-bug-prover", {{"environment", "browser+supabase"}}}}}}), "appUrl"));
    problems = bad({{"functional", {{"extraTools", {"Bash(psql:*)", "Bash(psql -h 127.0.0.1:*)", "Bash(psqlx:*)", "Bash(npm run e2e:*)", "mcp__x__y"}}}}});
    Check("functional.extraTools: an entry pool.DENY overrides is a problem (psql commits to the shared database; npm is a package manager); a mere prefix twin is not",
          problems.size() == 1 && problems[0].contains("Bash(psql:*)") && problems[0].contains("Bash(psql -h 127.0.0.1:*)") && problems[0].contains("Bash(npm run e2e:*)")
          && !problems[0].contains("psqlx") && problems[0].contains("supabase environment"), Show(problems));
    Json withPassword = load().config;
    withPassword["supabase"] = {{"dbUrl", "postgresql://postgres:hunter2@127.0.0.1:54322/postgres"}, {"start", nullptr}, {"stop", nullptr}, {"notes", ""}};
    const Json rc = Config::Redacted(withPassword);
    Check("redacted: the dump's copy of the config masks the database password and drops _path", rc.at("supabase").at("dbUrl") == "postgresql://postgres:***@127.0.0.1:54322/postgres"
          && !DumpSpaced(rc).contains("hunter2") && !rc.contains("_path"));
    problems = bad({{"lenses", {{"repo-functional", false}}}});
    Check("a bare false under lenses is a shape problem, never an exception; lenses_off and environments fall back to the defaults", problems.size() == 1
          && problems[0].contains("must be an object") && Config::LensesOff(load().config).empty() && Config::Environments(load().config).at(fn) == "browser", Show(problems));
    Json allOff = Json::object();
    for (auto it = defaults.at("lenses").begin(); it != defaults.at("lenses").end(); ++it) allOff[it.key()] = {{"run", false}};
    problems = bad({{"lenses", allOff}});
    Check("every lens off is a problem", problems.size() == 1 && problems[0].contains("every lens is off"), Show(problems));
    const Json ex = Config::Example();
    Check("the example validates and is what process/templates/config.json holds", Config::Validate(ex).empty()
          && Dyn::Equal(Dyn::LoadJsonFile(fs::current_path() / "process" / "templates" / "config.json"), ex));
    const fs::path repo = td / "r";
    fs::create_directories(repo);
    Process::Run({"git", "-C", repo.string(), "init", "-q"});
    Process::Run({"git", "-C", repo.string(), "config", "user.email", "me@example.com"});
    Check("authors: the configured list, else git config user.email", Config::Authors({{"authors", {"a@b.c"}}}, repo) == std::vector<std::string>{"a@b.c"}
          && Config::Authors({{"authors", nullptr}}, repo) == std::vector<std::string>{"me@example.com"});
    std::ofstream(td / "u.json", std::ios::binary) << "{}";
    Check("login_fixture: the first candidate that exists", Config::LoginFixture({{"functional", {{"login", {{"fixtures", {"nope.json", "u.json"}}}}}}}, td) == "u.json"
          && !Config::LoginFixture({{"functional", {{"login", {{"fixtures", Json::array()}}}}}}, td));
    fs::remove_all(td);
    return Failures ? 1 : 0;
}