mozart/cargoxx
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

[M5+] drop curated linkdb JSON; SQLite overlay is the single source

Browse Source
This commit is contained in:
Amadey Vorontsov
2026-05-13 23:28:36 +00:00
parent 5db915e576
commit 653b9fbb8d
12 changed files with 193 additions and 656 deletions
Download Patch File Download Diff File Expand all files Collapse all files

45
tests/cmd_add.cpp
View File

@@ -1,12 +1,15 @@
#include <catch2/catch_test_macros.hpp>
import cargoxx.cli;
import cargoxx.linkdb;
import cargoxx.manifest;
import cargoxx.util;
import std;
using cargoxx::cli::cmd_add;
using cargoxx::cli::cmd_new;
using cargoxx::linkdb::Database;
using cargoxx::linkdb::Recipe;
using cargoxx::util::ErrorCode;
namespace manifest = cargoxx::manifest;
@@ -36,11 +39,25 @@ auto scaffold(const std::filesystem::path& parent) -> std::filesystem::path {
return parent / "app";
}
auto seed_fmt(const std::filesystem::path& overlay) {
auto db = Database::open(overlay);
REQUIRE(db.has_value());
REQUIRE(db->add_manual("fmt", "*",
Recipe{
.nixpkgs_attr = "fmt_10",
.find_package = "fmt CONFIG REQUIRED",
.targets = {"fmt::fmt"},
.source = "manual",
})
.has_value());
}
} // namespace
TEST_CASE("cmd_add appends a string-form dependency", "[cli][add]") {
auto parent = fresh_dir();
auto root = scaffold(parent);
seed_fmt(overlay_path(parent));
auto r = cmd_add(root, "fmt", "10.2.0", {}, overlay_path(parent));
REQUIRE(r.has_value());
@@ -53,25 +70,10 @@ TEST_CASE("cmd_add appends a string-form dependency", "[cli][add]") {
REQUIRE(m->dependencies[0].components.empty());
}
TEST_CASE("cmd_add stores components when provided", "[cli][add]") {
auto parent = fresh_dir();
auto root = scaffold(parent);
auto r = cmd_add(root, "abseil-cpp", "20240116.0", {"strings", "base"},
overlay_path(parent));
REQUIRE(r.has_value());
auto m = manifest::parse(root / "Cargoxx.toml");
REQUIRE(m.has_value());
REQUIRE(m->dependencies.size() == 1);
REQUIRE(m->dependencies[0].name == "abseil-cpp");
REQUIRE(m->dependencies[0].components ==
std::vector<std::string>{"strings", "base"});
}
TEST_CASE("cmd_add accepts an empty version and stores '*'", "[cli][add]") {
auto parent = fresh_dir();
auto root = scaffold(parent);
seed_fmt(overlay_path(parent));
auto r = cmd_add(root, "fmt", "", {}, overlay_path(parent));
REQUIRE(r.has_value());
@@ -105,6 +107,7 @@ TEST_CASE("cmd_add rejects an unknown package", "[cli][add]") {
TEST_CASE("cmd_add rejects an already-declared dep", "[cli][add]") {
auto parent = fresh_dir();
auto root = scaffold(parent);
seed_fmt(overlay_path(parent));
REQUIRE(cmd_add(root, "fmt", "10.2.0", {}, overlay_path(parent)).has_value());
@@ -112,13 +115,3 @@ TEST_CASE("cmd_add rejects an already-declared dep", "[cli][add]") {
REQUIRE_FALSE(r.has_value());
REQUIRE(r.error().code == ErrorCode::ManifestInvalidField);
}
TEST_CASE("cmd_add rejects componentized package without components",
"[cli][add]") {
auto parent = fresh_dir();
auto root = scaffold(parent);
auto r = cmd_add(root, "abseil-cpp", "20240116.0", {}, overlay_path(parent));
REQUIRE_FALSE(r.has_value());
REQUIRE(r.error().code == ErrorCode::LinkdbComponentNotSupported);
}

58
tests/cmd_build.cpp
View File

@@ -1,6 +1,7 @@
#include <catch2/catch_test_macros.hpp>
import cargoxx.cli;
import cargoxx.linkdb;
import cargoxx.manifest;
import cargoxx.lockfile;
import cargoxx.util;
@@ -8,6 +9,8 @@ import std;
using cargoxx::cli::cmd_build;
using cargoxx::cli::cmd_new;
using cargoxx::linkdb::Database;
using cargoxx::linkdb::Recipe;
using cargoxx::util::ErrorCode;
namespace manifest = cargoxx::manifest;
namespace lockfile = cargoxx::lockfile;
@@ -43,6 +46,13 @@ auto add_dep(const std::filesystem::path& root, const std::string& name,
REQUIRE(manifest::write(*m, path).has_value());
}
auto seed_recipe(const std::filesystem::path& overlay, const std::string& package,
const std::string& version_range, const Recipe& r) {
auto db = Database::open(overlay);
REQUIRE(db.has_value());
REQUIRE(db->add_manual(package, version_range, r).has_value());
}
} // namespace
TEST_CASE("cmd_build generates files for a no-deps binary project",
@@ -82,12 +92,19 @@ TEST_CASE("cmd_build generates files for a library project", "[cli][build]") {
REQUIRE(cmake_text.find("add_executable") == std::string::npos);
}
TEST_CASE("cmd_build resolves a curated dep into find_package + targets",
TEST_CASE("cmd_build resolves a manually-seeded dep into find_package + targets",
"[cli][build]") {
auto parent = fresh_dir();
REQUIRE(cmd_new("app", false, parent).has_value());
auto root = parent / "app";
add_dep(root, "fmt", "10.2.0");
seed_recipe(overlay_path(parent), "fmt", ">=10.0.0",
Recipe{
.nixpkgs_attr = "fmt_10",
.find_package = "fmt CONFIG REQUIRED",
.targets = {"fmt::fmt"},
.source = "manual",
});
auto r = cmd_build(root, true, false, std::nullopt, overlay_path(parent));
REQUIRE(r.has_value());
@@ -100,35 +117,33 @@ TEST_CASE("cmd_build resolves a curated dep into find_package + targets",
REQUIRE(flake_text.find("pkgs.fmt_10") != std::string::npos);
}
TEST_CASE("cmd_build resolves a componentized dep", "[cli][build]") {
auto parent = fresh_dir();
REQUIRE(cmd_new("app", false, parent).has_value());
auto root = parent / "app";
add_dep(root, "abseil-cpp", "20240116.0", {"strings", "base"});
auto r = cmd_build(root, true, false, std::nullopt, overlay_path(parent));
REQUIRE(r.has_value());
auto cmake_text = read_file(root / "build" / "CMakeLists.txt");
REQUIRE(cmake_text.find("find_package(absl CONFIG REQUIRED)") !=
std::string::npos);
REQUIRE(cmake_text.find("absl::strings") != std::string::npos);
REQUIRE(cmake_text.find("absl::base") != std::string::npos);
}
TEST_CASE("cmd_build synthesizes a lockfile entry per dep", "[cli][build]") {
auto parent = fresh_dir();
REQUIRE(cmd_new("app", false, parent).has_value());
auto root = parent / "app";
add_dep(root, "fmt", "10.2.0");
add_dep(root, "spdlog", "1.13.0");
seed_recipe(overlay_path(parent), "fmt", ">=10.0.0",
Recipe{
.nixpkgs_attr = "fmt_10",
.find_package = "fmt CONFIG REQUIRED",
.targets = {"fmt::fmt"},
.source = "manual",
});
seed_recipe(overlay_path(parent), "spdlog", "*",
Recipe{
.nixpkgs_attr = "spdlog",
.find_package = "spdlog CONFIG REQUIRED",
.targets = {"spdlog::spdlog"},
.source = "manual",
});
auto r = cmd_build(root, true, false, std::nullopt, overlay_path(parent));
REQUIRE(r.has_value());
auto lock = lockfile::parse(root / "Cargoxx.lock");
REQUIRE(lock.has_value());
REQUIRE(lock->packages.size() == 3); // root + fmt + spdlog
REQUIRE(lock->packages.size() == 3);
REQUIRE(lock->packages[0].name == "app");
REQUIRE(lock->packages[0].dependencies.size() == 2);
}
@@ -172,6 +187,13 @@ TEST_CASE("cmd_build is idempotent — second run produces identical files",
REQUIRE(cmd_new("app", false, parent).has_value());
auto root = parent / "app";
add_dep(root, "fmt", "10.2.0");
seed_recipe(overlay_path(parent), "fmt", ">=10.0.0",
Recipe{
.nixpkgs_attr = "fmt_10",
.find_package = "fmt CONFIG REQUIRED",
.targets = {"fmt::fmt"},
.source = "manual",
});
REQUIRE(cmd_build(root, true, false, std::nullopt, overlay_path(parent)).has_value());
auto first_cmake = read_file(root / "build" / "CMakeLists.txt");

20
tests/cmd_remove.cpp
View File

@@ -1,6 +1,7 @@
#include <catch2/catch_test_macros.hpp>
import cargoxx.cli;
import cargoxx.linkdb;
import cargoxx.manifest;
import cargoxx.util;
import std;
@@ -8,6 +9,8 @@ import std;
using cargoxx::cli::cmd_add;
using cargoxx::cli::cmd_new;
using cargoxx::cli::cmd_remove;
using cargoxx::linkdb::Database;
using cargoxx::linkdb::Recipe;
using cargoxx::util::ErrorCode;
namespace manifest = cargoxx::manifest;
@@ -36,11 +39,26 @@ auto scaffold(const std::filesystem::path& parent) -> std::filesystem::path {
return parent / "app";
}
auto seed_recipe(const std::filesystem::path& overlay, const std::string& name,
const std::string& nixpkgs_attr) {
auto db = Database::open(overlay);
REQUIRE(db.has_value());
REQUIRE(db->add_manual(name, "*",
Recipe{
.nixpkgs_attr = nixpkgs_attr,
.find_package = std::format("{} CONFIG REQUIRED", name),
.targets = {std::format("{}::{}", name, name)},
.source = "manual",
})
.has_value());
}
} // namespace
TEST_CASE("cmd_remove drops the dependency", "[cli][remove]") {
auto parent = fresh_dir();
auto root = scaffold(parent);
seed_recipe(overlay_path(parent), "fmt", "fmt_10");
REQUIRE(cmd_add(root, "fmt", "10.2.0", {}, overlay_path(parent)).has_value());
REQUIRE(cmd_remove(root, "fmt").has_value());
@@ -53,6 +71,8 @@ TEST_CASE("cmd_remove drops the dependency", "[cli][remove]") {
TEST_CASE("cmd_remove leaves other deps in place", "[cli][remove]") {
auto parent = fresh_dir();
auto root = scaffold(parent);
seed_recipe(overlay_path(parent), "fmt", "fmt_10");
seed_recipe(overlay_path(parent), "spdlog", "spdlog");
REQUIRE(cmd_add(root, "fmt", "10.2.0", {}, overlay_path(parent)).has_value());
REQUIRE(cmd_add(root, "spdlog", "1.13.0", {}, overlay_path(parent)).has_value());

142
tests/linkdb_lookup.cpp
View File

@@ -6,8 +6,6 @@ import std;
using cargoxx::linkdb::Database;
using cargoxx::linkdb::Recipe;
using cargoxx::linkdb::expand_targets;
using cargoxx::linkdb::substitute_components;
using cargoxx::util::ErrorCode;
namespace {
@@ -27,134 +25,48 @@ auto open_db() -> Database {
} // namespace
TEST_CASE("Database::open loads the curated linkdb", "[linkdb]") {
TEST_CASE("Database::open succeeds against a fresh overlay path", "[linkdb]") {
auto db = open_db();
(void)db;
}
TEST_CASE("resolve returns the curated recipe for fmt 10", "[linkdb]") {
TEST_CASE("resolve fails on an empty database", "[linkdb]") {
auto db = open_db();
auto rec = db.resolve("fmt", "10.2.0");
REQUIRE_FALSE(rec.has_value());
REQUIRE(rec.error().code == ErrorCode::LinkdbUnknownPackage);
}
TEST_CASE("resolve returns a manually-added recipe", "[linkdb]") {
auto db = open_db();
auto add = db.add_manual("fmt", ">=10.0.0",
Recipe{
.nixpkgs_attr = "fmt_10",
.find_package = "fmt CONFIG REQUIRED",
.targets = {"fmt::fmt"},
.source = "manual",
});
REQUIRE(add.has_value());
auto rec = db.resolve("fmt", "10.2.0");
REQUIRE(rec.has_value());
REQUIRE(rec->nixpkgs_attr == "fmt_10");
REQUIRE(rec->find_package == "fmt CONFIG REQUIRED");
REQUIRE(rec->targets == std::vector<std::string>{"fmt::fmt"});
REQUIRE(rec->source == "curated");
REQUIRE(rec->source == "manual");
}
TEST_CASE("resolve returns the older fmt recipe for fmt 8", "[linkdb]") {
auto db = open_db();
auto rec = db.resolve("fmt", "8.1.0");
REQUIRE(rec.has_value());
REQUIRE(rec->nixpkgs_attr == "fmt_8");
}
TEST_CASE("resolve fails for an unknown package", "[linkdb]") {
auto db = open_db();
auto rec = db.resolve("obscurelib", "0.0.1");
REQUIRE_FALSE(rec.has_value());
REQUIRE(rec.error().code == ErrorCode::LinkdbUnknownPackage);
}
TEST_CASE("resolve substitutes abseil-cpp components", "[linkdb]") {
auto db = open_db();
auto rec = db.resolve("abseil-cpp", "20240116.0", {"strings", "base"});
REQUIRE(rec.has_value());
REQUIRE(rec->find_package == "absl CONFIG REQUIRED");
REQUIRE(rec->targets ==
std::vector<std::string>{"absl::strings", "absl::base"});
}
TEST_CASE("resolve fails when a componentized package gets no components",
"[linkdb]") {
auto db = open_db();
auto rec = db.resolve("abseil-cpp", "20240116.0");
REQUIRE_FALSE(rec.has_value());
REQUIRE(rec.error().code == ErrorCode::LinkdbComponentNotSupported);
}
TEST_CASE("resolve fails when components are passed to a non-componentized package",
TEST_CASE("resolve fails when components are passed but the row is non-componentized",
"[linkdb]") {
auto db = open_db();
(void)db.add_manual("fmt", "*",
Recipe{
.nixpkgs_attr = "fmt_10",
.find_package = "fmt CONFIG REQUIRED",
.targets = {"fmt::fmt"},
.source = "manual",
});
auto rec = db.resolve("fmt", "10.2.0", {"core"});
REQUIRE_FALSE(rec.has_value());
REQUIRE(rec.error().code == ErrorCode::LinkdbComponentNotSupported);
}
TEST_CASE("resolve handles wildcard versions", "[linkdb]") {
auto db = open_db();
auto rec = db.resolve("openssl", "3.2.0");
REQUIRE(rec.has_value());
REQUIRE(rec->find_package == "OpenSSL REQUIRED");
REQUIRE(rec->targets ==
std::vector<std::string>{"OpenSSL::SSL", "OpenSSL::Crypto"});
}
TEST_CASE("resolve covers all 25 curated packages", "[linkdb]") {
auto db = open_db();
struct Sample {
std::string name;
std::string version;
std::vector<std::string> components;
};
const std::vector<Sample> samples = {
{"fmt", "10.2.0", {}},
{"spdlog", "1.13.0", {}},
{"nlohmann_json", "3.11.0", {}},
{"boost", "1.84.0", {}},
{"openssl", "3.2.0", {}},
{"zlib", "1.3.0", {}},
{"sqlite3", "3.45.0", {}},
{"curl", "8.5.0", {}},
{"protobuf", "25.0.0", {}},
{"grpc", "1.60.0", {}},
{"abseil-cpp", "20240116.0", {"strings"}},
{"gtest", "1.14.0", {}},
{"catch2", "3.5.0", {}},
{"eigen", "3.4.0", {}},
{"tbb", "2021.10.0", {}},
{"libpng", "1.6.40", {}},
{"libjpeg", "3.0.1", {}},
{"freetype", "2.13.2", {}},
{"glfw", "3.3.9", {}},
{"glm", "0.9.9.8", {}},
{"sdl2", "2.28.5", {}},
{"cli11", "2.4.1", {}},
{"cxxopts", "3.2.0", {}},
{"range-v3", "0.12.0", {}},
{"magic_enum", "0.9.5", {}},
};
for (const auto& s : samples) {
auto rec = db.resolve(s.name, s.version, s.components);
INFO("resolving " << s.name);
REQUIRE(rec.has_value());
REQUIRE_FALSE(rec->nixpkgs_attr.empty());
REQUIRE_FALSE(rec->find_package.empty());
REQUIRE_FALSE(rec->targets.empty());
}
}
TEST_CASE("substitute_components is a no-op when marker is absent",
"[linkdb][substitute]") {
REQUIRE(substitute_components("foo bar", {"a", "b"}) == "foo bar");
}
TEST_CASE("substitute_components joins components with spaces",
"[linkdb][substitute]") {
REQUIRE(substitute_components("X {{components}} Y", {"a", "b", "c"}) ==
"X a b c Y");
}
TEST_CASE("expand_targets fans out per-component templates",
"[linkdb][substitute]") {
REQUIRE(expand_targets({"Boost::{{component}}"}, {"filesystem", "system"}) ==
std::vector<std::string>{"Boost::filesystem", "Boost::system"});
}
TEST_CASE("expand_targets keeps non-templated targets verbatim",
"[linkdb][substitute]") {
REQUIRE(expand_targets({"OpenSSL::SSL", "OpenSSL::Crypto"}, {}) ==
std::vector<std::string>{"OpenSSL::SSL", "OpenSSL::Crypto"});
}

16
tests/linkdb_overlay.cpp
View File

@@ -47,18 +47,17 @@ TEST_CASE("add_manual then resolve returns the manual recipe",
REQUIRE(got->source == "manual");
}
TEST_CASE("manual entry overrides curated for the same package",
"[linkdb][overlay]") {
TEST_CASE("manual entry resolves on subsequent open", "[linkdb][overlay]") {
auto db = Database::open(fresh_overlay());
REQUIRE(db.has_value());
Recipe override_r{
Recipe r{
.nixpkgs_attr = "fmt_pinned",
.find_package = "fmt CONFIG REQUIRED",
.targets = {"fmt::fmt"},
.source = "manual",
};
REQUIRE(db->add_manual("fmt", ">=10.0.0", override_r).has_value());
REQUIRE(db->add_manual("fmt", ">=10.0.0", r).has_value());
auto got = db->resolve("fmt", "10.2.0");
REQUIRE(got.has_value());
@@ -79,13 +78,10 @@ TEST_CASE("manual entry is constrained by version_range",
};
REQUIRE(db->add_manual("fmt", ">=11.0.0", r).has_value());
// 10.x falls outside the manual range and falls through to curated
auto curated = db->resolve("fmt", "10.2.0");
REQUIRE(curated.has_value());
REQUIRE(curated->source == "curated");
REQUIRE(curated->nixpkgs_attr == "fmt_10");
auto miss = db->resolve("fmt", "10.2.0");
REQUIRE_FALSE(miss.has_value());
REQUIRE(miss.error().code == ErrorCode::LinkdbUnknownPackage);
// 11.x matches the manual range
auto manual = db->resolve("fmt", "11.0.0");
REQUIRE(manual.has_value());
REQUIRE(manual->source == "manual");

6
tests/verify_link_unit.cpp
View File

@@ -94,13 +94,11 @@ TEST_CASE("verify_link rolls the provisional row back when the build fails",
REQUIRE_FALSE(r.has_value());
REQUIRE(r.error().code == cargoxx::util::ErrorCode::BuildCmakeFailed);
// The conan-source row must be gone; resolve falls through to the
// curated linkdb (which has its own fmt recipe with source = "curated").
auto db = Database::open(req.overlay_path);
REQUIRE(db.has_value());
auto rec = db->resolve("fmt", "10.2.0", {});
REQUIRE(rec.has_value());
REQUIRE(rec->source == "curated");
REQUIRE_FALSE(rec.has_value());
REQUIRE(rec.error().code == cargoxx::util::ErrorCode::LinkdbUnknownPackage);
}
TEST_CASE("verify_link cleans up its scratch project", "[resolver][verify_link]") {