{

{ auto g = graph({}); std::vector<std::string> order; assert(g.topological_order(order)); assert(order.empty()); }

{ auto g = graph({module("auth")}); std::vector<std::string> c; assert(g.dependency_closure("auth", c)); assert((c == std::vector<std::string>{"auth"})); }

{ auto g = graph({module("orders", {"users"}), module("auth"), module("users", {"auth"}), module("billing", {"auth"})}); std::vector<std::string> order; assert(g.topological_order(order)); assert((order == std::vector<std::string>{"auth", "billing", "users", "orders"})); std::vector<std::string> c; assert(g.dependency_closure("orders", c)); assert((c == std::vector<std::string>{"auth", "users", "orders"})); }

{ auto g = graph({module("root", {"left", "right"}), module("left", {"leaf"}), module("right", {"leaf"}), module("leaf")}); std::vector<std::string> c; assert(g.dependency_closure("root", c)); assert((c == std::vector<std::string>{"leaf", "left", "right", "root"})); }

invalid({module("a", {"missing"})}); invalid({module("a", {"a"})}); invalid({module("foo-bar"), module("foo_bar")}); invalid({module("Auth"), module("auth")}); invalid({module("a", {"b"}), module("b", {"a"})}); invalid({module("a", {"b"}), module("b", {"c"}), module("c", {"a"})}); invalid({module("a", {"b"}), module("b", {"a"}), module("c", {"d"}), module("d", {"c"})});

invalid({module("enabled", {"disabled"}), module("disabled", {}, false)});

{ auto g = graph({module("live"), module("off", {}, false)}); std::vector<std::string> active; assert(g.active_closure(active)); assert((active == std::vector<std::string>{"live"})); }

namespace fs = std::filesystem; const fs::path root = fs::temp_directory_path() / "vix_module_graph_tests"; fs::remove_all(root); fs::create_directories(root / "modules/with space"); fs::create_directories(root / "modules/a");

{ auto g = graph({module("space", {}, true, "modules/with space")}); std::string e; assert(g.validate_paths(root, true, e)); }

{ auto g = graph({module("a", {}, true, "modules/a"), module("b", {}, true, "modules/./a")}); std::string e; assert(!g.validate_paths(root, false, e)); }

{ auto g = graph({module("outside", {}, true, "../outside")}); std::string e; assert(!g.validate_paths(root, false, e)); }

{ auto g = graph({module("file", {}, true, "file")}); std::ofstream(root / "file") << "x"; std::string e; assert(!g.validate_paths(root, false, e)); }

for (int count : {10, 100, 500}) { std::vector<AppModule> modules; for (int i=0;i<count;++i) { std::vector<std::string> deps; if (i) deps.push_back("m" + std::to_string(i-1)); if (i > 2 && i % 3 == 0) deps.push_back("m" + std::to_string(i-3)); modules.push_back(module("m" + std::to_string(i), deps)); } auto g = graph(modules); std::vector<std::string> order; assert(g.topological_order(order)); assert(order.size() == modules.size()); modules.front().depends.push_back("m" + std::to_string(count-1)); std::string e; auto cyclic = ModuleGraph::from_app_modules(modules, e); assert(!cyclic.valid()); }

fs::remove_all(root); std::cout << "ModuleGraphTests passed\n";