613 lines
33 KiB
C++
613 lines
33 KiB
C++
#include "./parser_helper.h"
|
|
|
|
#include "../logging.h"
|
|
#include "../serversetup.h"
|
|
|
|
#include "../buildactions/buildaction.h"
|
|
#include "../buildactions/buildactionprivate.h"
|
|
#include "../buildactions/subprocess.h"
|
|
|
|
#include <c++utilities/conversion/stringconversion.h>
|
|
#include <c++utilities/io/ansiescapecodes.h>
|
|
#include <c++utilities/io/misc.h>
|
|
#include <c++utilities/io/path.h>
|
|
#include <c++utilities/tests/testutils.h>
|
|
using CppUtilities::operator<<; // must be visible prior to the call site
|
|
|
|
#include <cppunit/TestFixture.h>
|
|
#include <cppunit/extensions/HelperMacros.h>
|
|
|
|
#include <c++utilities/tests/outputcheck.h>
|
|
|
|
#include <boost/asio/executor_work_guard.hpp>
|
|
#include <boost/process/search_path.hpp>
|
|
|
|
#include <chrono>
|
|
|
|
using namespace std;
|
|
using namespace CPPUNIT_NS;
|
|
using namespace CppUtilities;
|
|
using namespace CppUtilities::Literals;
|
|
|
|
using namespace LibRepoMgr;
|
|
|
|
/*!
|
|
* \brief The BuildActionsTests class contains tests for classes/functions related to build actions.
|
|
*/
|
|
class BuildActionsTests : public TestFixture {
|
|
CPPUNIT_TEST_SUITE(BuildActionsTests);
|
|
CPPUNIT_TEST(testLogging);
|
|
CPPUNIT_TEST(testProcessSession);
|
|
CPPUNIT_TEST(testBuildActionProcess);
|
|
CPPUNIT_TEST(testBufferSearch);
|
|
CPPUNIT_TEST(testParsingInfoFromPkgFiles);
|
|
CPPUNIT_TEST(testPreparingBuild);
|
|
CPPUNIT_TEST(testConductingBuild);
|
|
CPPUNIT_TEST_SUITE_END();
|
|
|
|
public:
|
|
BuildActionsTests();
|
|
void setUp() override;
|
|
void tearDown() override;
|
|
|
|
void testLogging();
|
|
void testProcessSession();
|
|
void testBuildActionProcess();
|
|
void testBufferSearch();
|
|
void testParsingInfoFromPkgFiles();
|
|
void testPreparingBuild();
|
|
void testConductingBuild();
|
|
|
|
private:
|
|
void loadBasicTestSetup();
|
|
void loadTestConfig();
|
|
void logTestSetup();
|
|
template <typename InternalBuildActionType> void setupBuildAction();
|
|
void resetBuildAction();
|
|
void runBuildAction(const char *message, TimeSpan timeout = TimeSpan::fromSeconds(5));
|
|
template <typename InternalBuildActionType> InternalBuildActionType *internalBuildAction();
|
|
|
|
ServiceSetup m_setup;
|
|
std::shared_ptr<BuildAction> m_buildAction;
|
|
std::filesystem::path m_workingDir;
|
|
double m_timeoutFactor = 0.0;
|
|
};
|
|
|
|
CPPUNIT_TEST_SUITE_REGISTRATION(BuildActionsTests);
|
|
|
|
BuildActionsTests::BuildActionsTests()
|
|
{
|
|
if (const char *noBuildActionTimeout = std::getenv("BUILD_ACTION_TIMEOUT_FACTOR")) {
|
|
m_timeoutFactor = stringToNumber<double>(noBuildActionTimeout);
|
|
}
|
|
}
|
|
|
|
void BuildActionsTests::setUp()
|
|
{
|
|
// save the working directory; the code under test might change it and we want to restore the initial working directory later
|
|
m_workingDir = std::filesystem::current_path();
|
|
cerr << EscapeCodes::Phrases::Info << "test working directory: " << m_workingDir.native() << endl;
|
|
}
|
|
|
|
void BuildActionsTests::tearDown()
|
|
{
|
|
std::filesystem::current_path(m_workingDir);
|
|
}
|
|
|
|
/*!
|
|
* \brief Assigns certain build variables to use fake scripts (instead of invoking e.g. the real makepkg).
|
|
* \remarks The fake scripts are essentially no-ops which merely print the script name and the passed arguments.
|
|
*/
|
|
void BuildActionsTests::loadBasicTestSetup()
|
|
{
|
|
m_setup.workingDirectory = TestApplication::instance()->workingDirectory();
|
|
m_setup.building.workingDirectory = m_setup.workingDirectory + "/building";
|
|
m_setup.building.makePkgPath = std::filesystem::absolute(testFilePath("scripts/fake_makepkg.sh"));
|
|
m_setup.building.makeChrootPkgPath = std::filesystem::absolute(testFilePath("scripts/fake_makechrootpkg.sh"));
|
|
m_setup.building.updatePkgSumsPath = std::filesystem::absolute(testFilePath("scripts/fake_updatepkgsums.sh"));
|
|
m_setup.building.repoAddPath = std::filesystem::absolute(testFilePath("scripts/fake_repo_add.sh"));
|
|
m_setup.building.gpgPath = std::filesystem::absolute(testFilePath("scripts/fake_gpg.sh"));
|
|
m_setup.building.defaultGpgKey = "1234567890";
|
|
m_setup.configFilePath = std::filesystem::absolute(testFilePath("test-config/server.conf"));
|
|
|
|
std::filesystem::remove_all(m_setup.workingDirectory);
|
|
std::filesystem::create_directories(m_setup.building.workingDirectory);
|
|
}
|
|
|
|
/*!
|
|
* \brief Runs the startup code almost like the actual service does.
|
|
* \remarks Changes the current working directory! Make paths obtained via testFilePath() absolute before calling this function
|
|
* if they are supposed to be used later.
|
|
*/
|
|
void BuildActionsTests::loadTestConfig()
|
|
{
|
|
m_setup.loadConfigFiles(false);
|
|
m_setup.building.workingDirectory = m_setup.workingDirectory + "/building";
|
|
m_setup.printDatabases();
|
|
cerr << EscapeCodes::Phrases::Info << "current working directory: " << std::filesystem::current_path() << endl;
|
|
cerr << EscapeCodes::Phrases::Info << "setup working directory: " << m_setup.workingDirectory << endl;
|
|
logTestSetup();
|
|
}
|
|
|
|
/*!
|
|
* \brief Logs all databases and packages of the current test setup.
|
|
*/
|
|
void BuildActionsTests::logTestSetup()
|
|
{
|
|
for (const auto &db : m_setup.config.databases) {
|
|
cout << EscapeCodes::Phrases::Info << "Packages of " << db.name << ':' << EscapeCodes::Phrases::End;
|
|
for (const auto &[pkgName, pkg] : db.packages) {
|
|
cout << " - " << pkgName << '\n';
|
|
}
|
|
}
|
|
cout.flush();
|
|
}
|
|
|
|
/*!
|
|
* \brief Initializes the fixture's build action.helper
|
|
*/
|
|
template <typename InternalBuildActionType> void BuildActionsTests::setupBuildAction()
|
|
{
|
|
m_buildAction = std::make_shared<BuildAction>(0, &m_setup);
|
|
}
|
|
|
|
/*!
|
|
* \brief Resets the fixture's build action.
|
|
*/
|
|
void BuildActionsTests::resetBuildAction()
|
|
{
|
|
m_buildAction->status = BuildActionStatus::Created;
|
|
m_buildAction->result = BuildActionResult::None;
|
|
m_buildAction->resultData = std::string();
|
|
}
|
|
|
|
/*!
|
|
* \brief Runs the fixture's build action (initialized via setupBuildAction()) until it has finished.
|
|
* \param message The message for asserting whether the build action has finished yet.
|
|
* \param timeout The max. time to wait for the build action to finish. It does not interrupt the handler which is currently
|
|
* executed (so tests can still get stuck).
|
|
*
|
|
*/
|
|
void BuildActionsTests::runBuildAction(const char *message, CppUtilities::TimeSpan timeout)
|
|
{
|
|
resetBuildAction();
|
|
m_buildAction->start(m_setup);
|
|
auto &ioc = m_setup.building.ioContext;
|
|
ioc.restart();
|
|
boost::asio::executor_work_guard<boost::asio::io_context::executor_type> workGuard = boost::asio::make_work_guard(ioc);
|
|
m_buildAction->setConcludeHandler([&workGuard] { workGuard.reset(); });
|
|
if (m_timeoutFactor == 0.0) {
|
|
ioc.run();
|
|
} else {
|
|
ioc.run_for(std::chrono::microseconds(static_cast<std::chrono::microseconds::rep>((timeout * m_timeoutFactor).totalMicroseconds())));
|
|
}
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE(message, BuildActionStatus::Finished, m_buildAction->status);
|
|
}
|
|
|
|
/*!
|
|
* \brief Returns the internal build action for the fixture's build action.
|
|
* \remarks Invokes undefined behavior if \tp InternalBuildActionType is not the actual type.
|
|
*/
|
|
template <typename InternalBuildActionType> InternalBuildActionType *BuildActionsTests::internalBuildAction()
|
|
{
|
|
auto *const internalBuildAction = m_buildAction->m_internalBuildAction.get();
|
|
CPPUNIT_ASSERT_MESSAGE("internal build action assigned", internalBuildAction);
|
|
return static_cast<InternalBuildActionType *>(internalBuildAction);
|
|
}
|
|
|
|
/*!
|
|
* \brief Tests basic logging.
|
|
*/
|
|
void BuildActionsTests::testLogging()
|
|
{
|
|
using namespace EscapeCodes;
|
|
m_buildAction = make_shared<BuildAction>(0, &m_setup);
|
|
{
|
|
const auto stderrCheck = OutputCheck(
|
|
[](const std::string &output) {
|
|
TESTUTILS_ASSERT_LIKE_FLAGS(
|
|
"messages logged on stderr", ".*ERROR.*some error: message.*\n.*info.*\n.*", std::regex::extended, output);
|
|
},
|
|
cerr);
|
|
m_buildAction->log()(Phrases::ErrorMessage, "some error: ", "message", '\n');
|
|
m_buildAction->log()(Phrases::InfoMessage, "info", '\n');
|
|
}
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("messages added to build action output",
|
|
"\e[1;31m==> ERROR: \e[0m\e[1msome error: message\n\e[1;37m==> \e[0m\e[1minfo\n"s, m_buildAction->output);
|
|
}
|
|
|
|
/*!
|
|
* \brief Tests the ProcessSession class (which is used to spawn processes within build actions capturing the output).
|
|
*/
|
|
void BuildActionsTests::testProcessSession()
|
|
{
|
|
auto &ioc = m_setup.building.ioContext;
|
|
auto session = std::make_shared<ProcessSession>(ioc, [&ioc](boost::process::child &&child, ProcessResult &&result) {
|
|
CPP_UTILITIES_UNUSED(child)
|
|
CPPUNIT_ASSERT_EQUAL(std::error_code(), result.errorCode);
|
|
CPPUNIT_ASSERT_EQUAL(0, result.exitCode);
|
|
CPPUNIT_ASSERT_EQUAL(std::string(), result.error);
|
|
CPPUNIT_ASSERT_EQUAL("line1\nline2"s, result.output);
|
|
ioc.stop();
|
|
});
|
|
session->launch(boost::process::search_path("echo"), "-n", "line1\nline2");
|
|
session.reset();
|
|
ioc.run();
|
|
}
|
|
|
|
/*!
|
|
* \brief Tests the BuildProcessSession class (which is used to spawn processes within build actions creating a log file).
|
|
*/
|
|
void BuildActionsTests::testBuildActionProcess()
|
|
{
|
|
m_buildAction = std::make_shared<BuildAction>(0, &m_setup);
|
|
|
|
const auto scriptPath = testFilePath("scripts/print_some_data.sh");
|
|
const auto logFilePath = std::filesystem::path(TestApplication::instance()->workingDirectory()) / "logfile.log";
|
|
std::filesystem::create_directory(logFilePath.parent_path());
|
|
if (std::filesystem::exists(logFilePath)) {
|
|
std::filesystem::remove(logFilePath);
|
|
}
|
|
|
|
auto &ioc = m_setup.building.ioContext;
|
|
auto session = std::make_shared<BuildProcessSession>(
|
|
m_buildAction.get(), ioc, "test", std::string(logFilePath), [&ioc](boost::process::child &&child, ProcessResult &&result) {
|
|
CPPUNIT_ASSERT_EQUAL(std::error_code(), result.errorCode);
|
|
CPPUNIT_ASSERT_EQUAL(0, result.exitCode);
|
|
CPPUNIT_ASSERT_GREATER(0, child.native_handle());
|
|
ioc.stop();
|
|
});
|
|
session->launch(scriptPath);
|
|
session.reset();
|
|
ioc.run();
|
|
|
|
const auto logFile = readFile(logFilePath);
|
|
const auto logLines = splitStringSimple<std::vector<std::string_view>>(logFile, "\r\n");
|
|
CPPUNIT_ASSERT_EQUAL(5002_st, logLines.size());
|
|
CPPUNIT_ASSERT_EQUAL("printing some numbers"sv, logLines.front());
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("trailing line break", ""sv, logLines.back());
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("last line", "line 5000"sv, logLines[logLines.size() - 2u]);
|
|
TESTUTILS_ASSERT_LIKE_FLAGS("PID logged", ".*Launched \"test\", PID\\: [0-9]+.*\n.*"s, std::regex::extended, m_buildAction->output);
|
|
}
|
|
|
|
/*!
|
|
* \brief Tests the BufferSearch class.
|
|
*/
|
|
void BuildActionsTests::testBufferSearch()
|
|
{
|
|
// make a buffer
|
|
BuildProcessSession::BufferPoolType bufferPool(30);
|
|
auto buffer = bufferPool.newBuffer();
|
|
|
|
// setup testing the search
|
|
std::string expectedResult;
|
|
bool hasResult = false;
|
|
BufferSearch bs("Updated version: ", "\e\n", "Starting build", [&expectedResult, &hasResult](std::string &&result) {
|
|
CPPUNIT_ASSERT_EQUAL(expectedResult, result);
|
|
CPPUNIT_ASSERT_MESSAGE("callback only invoked once", !hasResult);
|
|
hasResult = true;
|
|
});
|
|
|
|
// feed data into the search
|
|
bs(buffer, 0);
|
|
std::strcpy(buffer->data(), "Starting Updated");
|
|
bs(buffer, 16);
|
|
std::strcpy(buffer->data(), " version: some ");
|
|
bs(buffer, 15);
|
|
expectedResult = "some version number";
|
|
std::strcpy(buffer->data(), "version number\emore chars");
|
|
bs(buffer, 25);
|
|
CPPUNIT_ASSERT(hasResult);
|
|
std::strcpy(buffer->data(), "... Starting build ...");
|
|
bs(buffer, 22);
|
|
}
|
|
|
|
/*!
|
|
* \brief Tests the ReloadLibraryDependencies build action.
|
|
*/
|
|
void BuildActionsTests::testParsingInfoFromPkgFiles()
|
|
{
|
|
// init config
|
|
LibPkg::Config &config = m_setup.config;
|
|
config.databases = { { "foo.db" }, { "bar.db" }, { "baz.db" } };
|
|
|
|
// init db object
|
|
LibPkg::Database &fooDb = config.databases[0];
|
|
auto harfbuzz = fooDb.packages["mingw-w64-harfbuzz"] = LibPkg::Package::fromPkgFileName("mingw-w64-harfbuzz-1.4.2-1-any.pkg.tar.xz");
|
|
auto syncthingtray = fooDb.packages["syncthingtray"] = LibPkg::Package::fromPkgFileName("syncthingtray-0.6.2-1-x86_64.pkg.tar.xz");
|
|
fooDb.localPkgDir = directory(testFilePath("repo/foo/mingw-w64-harfbuzz-1.4.2-1-any.pkg.tar.xz"));
|
|
LibPkg::Database &barDb = config.databases[1];
|
|
auto cmake = barDb.packages["cmake"] = LibPkg::Package::fromPkgFileName("cmake-3.8.2-1-x86_64.pkg.tar.xz");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("origin", LibPkg::PackageOrigin::PackageFileName, cmake->origin);
|
|
barDb.localPkgDir = directory(testFilePath("repo/bar/cmake-3.8.2-1-x86_64.pkg.tar.xz"));
|
|
|
|
auto buildAction = std::make_shared<BuildAction>(0, &m_setup);
|
|
auto reloadLibDependencies = ReloadLibraryDependencies(m_setup, buildAction);
|
|
reloadLibDependencies.run();
|
|
const auto &messages = std::get<BuildActionMessages>(buildAction->resultData);
|
|
CPPUNIT_ASSERT_EQUAL(std::vector<std::string>(), messages.errors);
|
|
CPPUNIT_ASSERT_EQUAL(std::vector<std::string>(), messages.warnings);
|
|
CPPUNIT_ASSERT_EQUAL(std::vector<std::string>(), messages.notes);
|
|
|
|
using namespace TestHelper;
|
|
checkHarfbuzzPackagePeDependencies(*harfbuzz);
|
|
checkSyncthingTrayPackageSoDependencies(*syncthingtray);
|
|
checkCmakePackageSoDependencies(*cmake);
|
|
|
|
const auto pkgsRequiringLibGCC = config.findPackagesProvidingLibrary("pe-i386::libgcc_s_sjlj-1.dll", true);
|
|
CPPUNIT_ASSERT_EQUAL(1_st, pkgsRequiringLibGCC.size());
|
|
CPPUNIT_ASSERT_EQUAL(harfbuzz, pkgsRequiringLibGCC.front().pkg);
|
|
|
|
const auto pkgsProvidingLibSyncthingConnector = config.findPackagesProvidingLibrary("elf-x86_64::libsyncthingconnector.so.0.6.2", false);
|
|
CPPUNIT_ASSERT_EQUAL(1_st, pkgsProvidingLibSyncthingConnector.size());
|
|
CPPUNIT_ASSERT_EQUAL(syncthingtray, pkgsProvidingLibSyncthingConnector.front().pkg);
|
|
}
|
|
|
|
/*!
|
|
* \brief Tests the PrepareBuild build action.
|
|
*/
|
|
void BuildActionsTests::testPreparingBuild()
|
|
{
|
|
// get meta info
|
|
auto &metaInfo = m_setup.building.metaInfo;
|
|
const auto &typeInfo = metaInfo.typeInfoForId(BuildActionType::PrepareBuild);
|
|
const auto pkgbuildsDirsSetting = std::string(typeInfo.settings[static_cast<std::size_t>(PrepareBuildSettings::PKGBUILDsDirs)].param);
|
|
|
|
// load basic test setup and create build action
|
|
loadBasicTestSetup();
|
|
m_buildAction = std::make_shared<BuildAction>(0, &m_setup);
|
|
m_buildAction->type = BuildActionType::PrepareBuild;
|
|
m_buildAction->directory = "prepare-build-test";
|
|
m_buildAction->flags = static_cast<BuildActionFlagType>(PrepareBuildFlags::CleanSrcDir);
|
|
m_buildAction->settings[pkgbuildsDirsSetting] = std::filesystem::absolute(testDirPath("building/pkgbuilds"));
|
|
m_buildAction->packageNames = { "boost", "mingw-w64-gcc" };
|
|
|
|
// prepare test configuration
|
|
// - Pretend all dependencies of boost are there except "zstd-1.4.5-1-x86_64.pkg.tar.zst" (so zstd is supposed pulled into the build automatically).
|
|
// - There's a dummy package for zstd which incurs no further dependencies.
|
|
// - The package mingw-w64-gcc is also just a dummy here to test handling variants; it has no dependencies here.
|
|
loadTestConfig();
|
|
auto coreDb = m_setup.config.findDatabase("core", "x86_64");
|
|
CPPUNIT_ASSERT_MESSAGE("core db exists", coreDb);
|
|
for (const auto pkgFileName :
|
|
{ "python-3.8.6-1-x86_64.pkg.tar.zst"sv, "python2-2.7.18-2-x86_64.pkg.tar.zst"sv, "bzip2-1.0.8-4-x86_64.pkg.tar.zst"sv,
|
|
"findutils-4.7.0-2-x86_64.pkg.tar.xz"sv, "icu-67.1-1-x86_64.pkg.tar.zst"sv, "openmpi-4.0.5-2-x86_64.pkg.tar.zst"sv,
|
|
"python-numpy-1.19.4-1-x86_64.pkg.tar.zst"sv, "python2-numpy-1.16.6-1-x86_64.pkg.tar.zst"sv, "zlib-1:1.2.11-4-x86_64.pkg.tar.xz"sv }) {
|
|
coreDb->updatePackage(LibPkg::Package::fromPkgFileName(pkgFileName));
|
|
}
|
|
|
|
// run without destination database
|
|
runBuildAction("prepare build without destination db");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("failure without destination db", BuildActionResult::Failure, m_buildAction->result);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE(
|
|
"failure without destination db", "not exactly one destination database specified"s, std::get<std::string>(m_buildAction->resultData));
|
|
|
|
// run with destination database (yes, the database is called "boost" in this test setup as well)
|
|
m_buildAction->destinationDbs = { "boost" };
|
|
runBuildAction("prepare build: successful preparation");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("success", BuildActionResult::Success, m_buildAction->result);
|
|
CPPUNIT_ASSERT_MESSAGE("build preparation present", std::holds_alternative<BuildPreparation>(m_buildAction->resultData));
|
|
const auto &buildPreparation = std::get<BuildPreparation>(m_buildAction->resultData);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("target db set", "boost"s, buildPreparation.targetDb);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("target arch set", "x86_64"s, buildPreparation.targetArch);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("staging db set", "boost-staging"s, buildPreparation.stagingDb);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no cyclic leftovers", 0_st, buildPreparation.cyclicLeftovers.size());
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no warnings", 0_st, buildPreparation.warnings.size());
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no error", std::string(), buildPreparation.error);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("manually ordered not set", false, buildPreparation.manuallyOrdered);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("db config has 2 dbs", 2_st, buildPreparation.dbConfig.size());
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("first db", "boost"s, buildPreparation.dbConfig[0].first);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("second db", "core"s, buildPreparation.dbConfig[1].first);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("staging db config has 3 dbs", 3_st, buildPreparation.stagingDbConfig.size());
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("first staging db", "boost-staging"s, buildPreparation.stagingDbConfig[0].first);
|
|
const auto &batches = buildPreparation.batches;
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("two batches present", 2_st, batches.size());
|
|
const auto expectedFirstBatch = std::vector<std::string>{ "mingw-w64-gcc", "zstd" };
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("first batch", expectedFirstBatch, batches[0]);
|
|
const auto expectedSecondBatch = std::vector<std::string>{ "boost" };
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("second batch", expectedSecondBatch, batches[1]);
|
|
CPPUNIT_ASSERT_MESSAGE(
|
|
"build-preparation.json created", std::filesystem::is_regular_file("building/build-data/prepare-build-test/build-preparation.json"));
|
|
CPPUNIT_ASSERT_MESSAGE(
|
|
"build-progress.json created", std::filesystem::is_regular_file("building/build-data/prepare-build-test/build-progress.json"));
|
|
for (const auto pkg : { "boost"sv, "mingw-w64-gcc"sv, "zstd"sv }) {
|
|
CPPUNIT_ASSERT_MESSAGE(
|
|
"PKGBUILD for " % pkg + " created", std::filesystem::is_regular_file("building/build-data/prepare-build-test/" % pkg + "/src/PKGBUILD"));
|
|
}
|
|
}
|
|
|
|
/*!
|
|
* \brief Tests the ConductBuild build action.
|
|
*/
|
|
void BuildActionsTests::testConductingBuild()
|
|
{
|
|
// load basic test setup and create build action
|
|
loadBasicTestSetup();
|
|
m_buildAction = std::make_shared<BuildAction>(0, &m_setup);
|
|
m_buildAction->type = BuildActionType::ConductBuild;
|
|
m_buildAction->directory = "conduct-build-test";
|
|
m_buildAction->packageNames = { "boost" };
|
|
m_buildAction->flags = static_cast<BuildActionFlagType>(ConductBuildFlags::BuildAsFarAsPossible | ConductBuildFlags::SaveChrootOfFailures
|
|
| ConductBuildFlags::UpdateChecksums | ConductBuildFlags::AutoStaging);
|
|
|
|
// run without build preparation
|
|
runBuildAction("conduct build without build preparation");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("failure without preparation JSON", BuildActionResult::Failure, m_buildAction->result);
|
|
TESTUTILS_ASSERT_LIKE(
|
|
"no preparation JSON", "Unable to restore build-preparation.json:.*not exist.*", std::get<std::string>(m_buildAction->resultData));
|
|
|
|
// create fake build preparation
|
|
const auto origPkgbuildFile = workingCopyPathAs("building/build-data/conduct-build-test/boost/src/PKGBUILD", "orig-src-dir/boost/PKGBUILD");
|
|
const auto origSourceDir = std::filesystem::absolute(directory(origPkgbuildFile));
|
|
auto prepData = readFile(testFilePath("building/build-data/conduct-build-test/build-preparation.json"));
|
|
findAndReplace(prepData, "$ORIGINAL_SOURCE_DIRECTORY", origSourceDir.native());
|
|
findAndReplace(prepData, "$TEST_FILES_PATH", "TODO");
|
|
const auto buildDir = std::filesystem::absolute(workingCopyPath("building", WorkingCopyMode::NoCopy));
|
|
const auto prepFile
|
|
= std::filesystem::absolute(workingCopyPath("building/build-data/conduct-build-test/build-preparation.json", WorkingCopyMode::NoCopy));
|
|
writeFile(prepFile.native(), prepData);
|
|
auto progressData = readFile(testFilePath("building/build-data/conduct-build-test/build-progress.json"));
|
|
const auto progressFile
|
|
= std::filesystem::absolute(workingCopyPath("building/build-data/conduct-build-test/build-progress.json", WorkingCopyMode::NoCopy));
|
|
writeFile(progressFile.native(), progressData);
|
|
std::filesystem::copy(testDirPath("building/build-data/conduct-build-test/boost"),
|
|
m_setup.workingDirectory + "/building/build-data/conduct-build-test/boost", std::filesystem::copy_options::recursive);
|
|
|
|
// run without chroot configuration
|
|
runBuildAction("conduct build without chroot configuration");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("failure without chroot configuration", BuildActionResult::Failure, m_buildAction->result);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE(
|
|
"no chroot configuration", "The chroot directory is not configured."s, std::get<std::string>(m_buildAction->resultData));
|
|
|
|
// configure chroot directory
|
|
m_setup.building.chrootDir = testDirPath("test-config/chroot-dir");
|
|
|
|
// run with misconfigured destination db
|
|
runBuildAction("conduct build with misconfigured destination db (1)");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("failure without destination db (1)", BuildActionResult::Failure, m_buildAction->result);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("destination db missing (1)",
|
|
"Auto-staging is enabled but the staging database \"boost-staging@x86_64\" specified in build-preparation.json can not be found."s,
|
|
std::get<std::string>(m_buildAction->resultData));
|
|
loadTestConfig();
|
|
runBuildAction("conduct build with misconfigured destination db (2)");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("failure without destination db (2)", BuildActionResult::Failure, m_buildAction->result);
|
|
TESTUTILS_ASSERT_LIKE("destination db missing (2)", "Destination repository \"repos/boost/os/x86_64\" does not exist.*"s,
|
|
std::get<std::string>(m_buildAction->resultData));
|
|
|
|
// create repositories
|
|
const auto reposPath = testDirPath("test-config/repos");
|
|
const auto reposWorkingCopyPath = std::filesystem::path(m_setup.workingDirectory + "/repos");
|
|
std::filesystem::create_directory(reposWorkingCopyPath);
|
|
std::filesystem::copy(reposPath, reposWorkingCopyPath, std::filesystem::copy_options::recursive);
|
|
|
|
// run without chroot directory
|
|
runBuildAction("conduct build without chroot directory");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no chroot directory: results in failure", BuildActionResult::Failure, m_buildAction->result);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no chroot directory: result data states affected packages", "failed to build packages: boost"s,
|
|
std::get<std::string>(m_buildAction->resultData));
|
|
auto *internalData = internalBuildAction<ConductBuild>();
|
|
TESTUTILS_ASSERT_LIKE("no chroot directory: package-level error message",
|
|
"Chroot directory \".*/test-config/chroot-dir/arch-x86_64/root\" is no directory."s,
|
|
internalData->m_buildProgress.progressByPackage["boost"].error);
|
|
|
|
// create chroot directory
|
|
const auto chrootSkelPath = testDirPath("test-config/chroot-skel");
|
|
const auto chrootDirWorkingCopyPath = std::filesystem::path(m_setup.workingDirectory + "/chroot-dir");
|
|
const auto rootChrootWorkingCopyPath = chrootDirWorkingCopyPath / "arch-x86_64/root";
|
|
std::filesystem::create_directory(chrootDirWorkingCopyPath);
|
|
std::filesystem::copy(m_setup.building.chrootDir, chrootDirWorkingCopyPath, std::filesystem::copy_options::recursive);
|
|
std::filesystem::create_directories(rootChrootWorkingCopyPath);
|
|
std::filesystem::copy(chrootSkelPath, rootChrootWorkingCopyPath, std::filesystem::copy_options::recursive);
|
|
m_setup.building.chrootDir = chrootDirWorkingCopyPath.string(); // assign the created chroot directory
|
|
writeFile(progressFile.native(), progressData); // reset "build-progress.json" so the new chroot directory is actually used
|
|
|
|
// run without having makepkg actually producing any packages
|
|
runBuildAction("conduct build without producing any packages");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no packages produced: results in failure", BuildActionResult::Failure, m_buildAction->result);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no packages produced: result data states affected packages", "failed to build packages: boost"s,
|
|
std::get<std::string>(m_buildAction->resultData));
|
|
internalData = internalBuildAction<ConductBuild>();
|
|
TESTUTILS_ASSERT_LIKE("no packages produced: package-level error message",
|
|
"not all.*packages exist.*boost-1.73.0-1.src.tar.gz.*boost-libs-1\\.73\\.0-1-x86_64\\.pkg\\.tar\\.zst.*boost-1\\.73\\.0-1-x86_64\\.pkg\\.tar\\.zst"s,
|
|
internalData->m_buildProgress.progressByPackage["boost"].error);
|
|
CPPUNIT_ASSERT_MESSAGE(
|
|
"no packages produced: package considered finished", !internalData->m_buildProgress.progressByPackage["boost"].finished.isNull());
|
|
CPPUNIT_ASSERT_MESSAGE("no packages produced: package not added to repo", !internalData->m_buildProgress.progressByPackage["boost"].addedToRepo);
|
|
|
|
// prepare some actual packages
|
|
std::filesystem::copy(testFilePath("test-config/fake-build-artefacts/boost-1.73.0-1.src.tar.gz"),
|
|
buildDir / "build-data/conduct-build-test/boost/pkg/boost-1.73.0-1.src.tar.gz");
|
|
std::filesystem::copy(testFilePath("test-config/fake-build-artefacts/boost-1.73.0-1-x86_64.pkg.tar.zst"),
|
|
buildDir / "build-data/conduct-build-test/boost/pkg/boost-1.73.0-1-x86_64.pkg.tar.zst");
|
|
std::filesystem::copy(testFilePath("test-config/fake-build-artefacts/boost-libs-1.73.0-1-x86_64.pkg.tar.zst"),
|
|
buildDir / "build-data/conduct-build-test/boost/pkg/boost-libs-1.73.0-1-x86_64.pkg.tar.zst");
|
|
|
|
// conduct build without staging
|
|
runBuildAction("conduct build without staging");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no staging needed: success", BuildActionResult::Success, m_buildAction->result);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no staging needed: no result data present", ""s, std::get<std::string>(m_buildAction->resultData));
|
|
internalData = internalBuildAction<ConductBuild>();
|
|
CPPUNIT_ASSERT_MESSAGE("no staging needed: rebuild list empty", internalData->m_buildProgress.rebuildList.empty());
|
|
CPPUNIT_ASSERT_MESSAGE(
|
|
"no staging needed: package considered finished", !internalData->m_buildProgress.progressByPackage["boost"].finished.isNull());
|
|
CPPUNIT_ASSERT_MESSAGE("no staging needed: package added to repo", internalData->m_buildProgress.progressByPackage["boost"].addedToRepo);
|
|
|
|
// check whether log files have been created accordingly
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no staging needed: download log", "fake makepkg: -f --nodeps --nobuild --source\n"s,
|
|
readFile("building/build-data/conduct-build-test/boost/pkg/download.log"));
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE(
|
|
"no staging needed: updpkgsums log", "fake updatepkgsums: \n"s, readFile("building/build-data/conduct-build-test/boost/pkg/updpkgsums.log"));
|
|
TESTUTILS_ASSERT_LIKE("no staging needed: build log", "fake makechrootpkg: -c -u -C -r .*chroot-dir/arch-x86_64 -l buildservice --\n"s,
|
|
readFile("building/build-data/conduct-build-test/boost/pkg/build.log"));
|
|
TESTUTILS_ASSERT_LIKE("no staging needed: repo-add log",
|
|
"fake repo-add: boost.db.tar.zst boost(-libs)?-1\\.73\\.0-1-x86_64.pkg.tar.zst boost(-libs)?-1\\.73\\.0-1-x86_64.pkg.tar.zst\n"s,
|
|
readFile("building/build-data/conduct-build-test/boost/pkg/repo-add.log"));
|
|
|
|
// check whether packages have actually been added to repo
|
|
CPPUNIT_ASSERT_MESSAGE(
|
|
"no staging needed: package added to repo (0)", std::filesystem::is_regular_file("repos/boost/os/src/boost-1.73.0-1.src.tar.gz"));
|
|
CPPUNIT_ASSERT_MESSAGE(
|
|
"no staging needed: package added to repo (1)", std::filesystem::is_regular_file("repos/boost/os/x86_64/boost-1.73.0-1-x86_64.pkg.tar.zst"));
|
|
CPPUNIT_ASSERT_MESSAGE("no staging needed: package added to repo (2)",
|
|
std::filesystem::is_regular_file("repos/boost/os/x86_64/boost-libs-1.73.0-1-x86_64.pkg.tar.zst"));
|
|
CPPUNIT_ASSERT_MESSAGE("no staging needed: signature added to repo (0)",
|
|
std::filesystem::is_regular_file("repos/boost/os/x86_64/boost-1.73.0-1-x86_64.pkg.tar.zst.sig"));
|
|
CPPUNIT_ASSERT_MESSAGE("no staging needed: signature added to repo (1)",
|
|
std::filesystem::is_regular_file("repos/boost/os/x86_64/boost-libs-1.73.0-1-x86_64.pkg.tar.zst.sig"));
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("no staging needed: signature looks as expected",
|
|
"fake signature with GPG key 1234567890 boost-libs-1.73.0-1-x86_64.pkg.tar.zst\n"s,
|
|
readFile("repos/boost/os/x86_64/boost-libs-1.73.0-1-x86_64.pkg.tar.zst.sig"));
|
|
|
|
// add packages needing a rebuild to trigger auto-staging
|
|
m_setup.config.loadAllPackages(false);
|
|
auto *const boostDb = m_setup.config.findDatabase("boost"sv, "x86_64"sv);
|
|
auto *const miscDb = m_setup.config.findDatabase("misc"sv, "x86_64"sv);
|
|
CPPUNIT_ASSERT_MESSAGE("boost database present", boostDb);
|
|
CPPUNIT_ASSERT_MESSAGE("misc database present", miscDb);
|
|
auto &boostLibsPackage = boostDb->packages["boost-libs"];
|
|
boostLibsPackage->libprovides = { "elf-x86_64::libboost_regex.so.1.72.0" };
|
|
boostLibsPackage->libdepends = { "elf-x86_64::libstdc++.so.6" };
|
|
boostDb->forceUpdatePackage(boostLibsPackage);
|
|
auto &sourceHighlightPackage = miscDb->packages["source-highlight"];
|
|
sourceHighlightPackage->libprovides = { "elf-x86_64::libsource-highlight.so.4" };
|
|
sourceHighlightPackage->libdepends
|
|
= { "elf-x86_64::libboost_regex.so.1.72.0", "elf-x86_64::libsource-highlight.so.4", "elf-x86_64::libstdc++.so.6" };
|
|
miscDb->forceUpdatePackage(sourceHighlightPackage);
|
|
m_setup.printDatabases();
|
|
logTestSetup();
|
|
|
|
// conduct build with staging
|
|
writeFile(progressFile.native(), progressData); // reset "build-progress.json" so the package is re-considered
|
|
runBuildAction("conduct build with staging");
|
|
//CPPUNIT_ASSERT_EQUAL_MESSAGE("staging needed: success", BuildActionResult::Success, m_buildAction->result);
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("staging needed: no result data present", ""s, std::get<std::string>(m_buildAction->resultData));
|
|
internalData = internalBuildAction<ConductBuild>();
|
|
const auto &rebuildList = internalData->m_buildProgress.rebuildList;
|
|
const auto rebuildInfoForMisc = rebuildList.find("misc");
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE("staging needed: rebuild list contains 1 database", 1_st, rebuildList.size());
|
|
CPPUNIT_ASSERT_MESSAGE("staging needed: rebuild info for misc present", rebuildInfoForMisc != rebuildList.end());
|
|
const auto rebuildInfoForSourceHighlight = rebuildInfoForMisc->second.find("source-highlight");
|
|
const auto expectedLibprovides = std::vector<std::string>{ "elf-x86_64::libboost_regex.so.1.72.0" };
|
|
CPPUNIT_ASSERT_MESSAGE(
|
|
"staging needed: rebuild info for source-highlight present", rebuildInfoForSourceHighlight != rebuildInfoForMisc->second.end());
|
|
CPPUNIT_ASSERT_EQUAL_MESSAGE(
|
|
"staging needed: libprovides for source-highlight present", expectedLibprovides, rebuildInfoForSourceHighlight->second.libprovides);
|
|
|
|
// check whether log files have been created accordingly
|
|
TESTUTILS_ASSERT_LIKE("no staging needed: repo-add log",
|
|
"fake repo-add: boost-staging.db.tar.zst boost(-libs)?-1\\.73\\.0-1-x86_64.pkg.tar.zst boost(-libs)?-1\\.73\\.0-1-x86_64.pkg.tar.zst\n"s,
|
|
readFile("building/build-data/conduct-build-test/boost/pkg/repo-add.log"));
|
|
|
|
// check whether package have been added to staging repo
|
|
CPPUNIT_ASSERT_MESSAGE(
|
|
"staging needed: package added to repo (0)", std::filesystem::is_regular_file("repos/boost-staging/os/src/boost-1.73.0-1.src.tar.gz"));
|
|
CPPUNIT_ASSERT_MESSAGE("staging needed: package added to repo (1)",
|
|
std::filesystem::is_regular_file("repos/boost-staging/os/x86_64/boost-1.73.0-1-x86_64.pkg.tar.zst"));
|
|
CPPUNIT_ASSERT_MESSAGE("staging needed: package added to repo (2)",
|
|
std::filesystem::is_regular_file("repos/boost-staging/os/x86_64/boost-libs-1.73.0-1-x86_64.pkg.tar.zst"));
|
|
CPPUNIT_ASSERT_MESSAGE("staging needed: signature added to repo (0)",
|
|
std::filesystem::is_regular_file("repos/boost-staging/os/x86_64/boost-1.73.0-1-x86_64.pkg.tar.zst.sig"));
|
|
CPPUNIT_ASSERT_MESSAGE("staging needed: signature added to repo (1)",
|
|
std::filesystem::is_regular_file("repos/boost-staging/os/x86_64/boost-libs-1.73.0-1-x86_64.pkg.tar.zst.sig"));
|
|
}
|