From eb501f55287e080f796b64b46c3d4be5ebfdffe4 Mon Sep 17 00:00:00 2001 From: Iuri Matias Date: Fri, 10 Apr 2026 11:33:44 -0400 Subject: [PATCH] migrate to new api --- CMakeLists.txt | 3 +- metadata.json | 5 +- src/package_manager_impl.cpp | 218 +++++++++------------ src/package_manager_impl.h | 65 +++--- src/package_manager_loader.h | 18 -- tests/CMakeLists.txt | 8 - tests/test_directory_config.cpp | 30 +-- tests/test_keyring.cpp | 139 ++++++------- tests/test_package_manager.cpp | 132 ++++++------- tests/test_package_manager_integration.cpp | 22 +-- tests/test_scanning.cpp | 68 +++---- tests/test_signature.cpp | 151 +++++++------- 12 files changed, 355 insertions(+), 504 deletions(-) delete mode 100644 src/package_manager_loader.h diff --git a/CMakeLists.txt b/CMakeLists.txt index 4f9f4a7..5cd4f79 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -8,13 +8,12 @@ else() message(FATAL_ERROR "LogosModule.cmake not found. Set LOGOS_MODULE_BUILDER_ROOT.") endif() -# LogosProviderBase / LOGOS_METHOD — dispatch is generated under generated_code/ +# Universal module — generated_code/ is picked up automatically by LogosModule.cmake logos_module( NAME package_manager SOURCES src/package_manager_impl.h src/package_manager_impl.cpp - src/package_manager_loader.h EXTERNAL_LIBS package_manager_lib lgx diff --git a/metadata.json b/metadata.json index f5a50bf..6637410 100644 --- a/metadata.json +++ b/metadata.json @@ -4,7 +4,7 @@ "description": "Plugin manager for the Logos system", "author": "Logos Core Team", "type": "core", - "interface": "provider", + "interface": "universal", "category": "management", "main": "package_manager_plugin", "dependencies": [], @@ -12,6 +12,9 @@ "capabilities": ["plugin_installation"], "nix": { + "packages": { + "runtime": ["nlohmann_json"] + }, "external_libraries": [ { "name": "logos_pm" } ], diff --git a/src/package_manager_impl.cpp b/src/package_manager_impl.cpp index a693426..8bad5cc 100644 --- a/src/package_manager_impl.cpp +++ b/src/package_manager_impl.cpp @@ -1,16 +1,13 @@ #include "package_manager_impl.h" #include #include -#include -#include -#include -#include -#include +#include +#include +#include PackageManagerImpl::PackageManagerImpl() : m_lib(nullptr) { - qDebug() << "PackageManagerImpl created (new provider API)"; m_lib = new PackageManagerLib(); } @@ -20,228 +17,199 @@ PackageManagerImpl::~PackageManagerImpl() m_lib = nullptr; } -void PackageManagerImpl::onInit(LogosAPI* api) -{ - qDebug() << "PackageManagerImpl: LogosAPI initialized (new provider API)"; -} - -QVariantMap PackageManagerImpl::installPlugin(const QString& pluginPath, bool skipIfNotNewerVersion) +LogosMap PackageManagerImpl::installPlugin(const std::string& pluginPath, bool skipIfNotNewerVersion) { std::string errorMsg; std::string installedPluginPath; bool isCoreModule = false; std::string result = m_lib->installPluginFile( - pluginPath.toStdString(), errorMsg, skipIfNotNewerVersion, + pluginPath, errorMsg, skipIfNotNewerVersion, &installedPluginPath, &isCoreModule ); bool success = !result.empty(); - if (success && !installedPluginPath.empty()) { - onPluginFileInstalled(QString::fromStdString(installedPluginPath), isCoreModule); + if (success && !installedPluginPath.empty() && emitEvent) { + if (isCoreModule) { + emitEvent("corePluginFileInstalled", installedPluginPath); + } else { + emitEvent("uiPluginFileInstalled", installedPluginPath); + } } // Get signature info for the response - auto sigResult = m_lib->verifyPackageSignature(pluginPath.toStdString()); + auto sigResult = m_lib->verifyPackageSignature(pluginPath); - QFileInfo fi(pluginPath); - QVariantMap response; - response["name"] = fi.completeBaseName(); - response["path"] = success ? QString::fromStdString(installedPluginPath) : QString(); + std::string stem = std::filesystem::path(pluginPath).stem().string(); + + LogosMap response; + response["name"] = stem; + response["path"] = success ? installedPluginPath : std::string(); response["isCoreModule"] = isCoreModule; if (!success) { - response["error"] = QString::fromStdString(errorMsg); + response["error"] = errorMsg; } // Add signature info if (sigResult.is_signed) { - response["signatureStatus"] = sigResult.signature_valid && sigResult.package_valid - ? QString("signed") : QString("invalid"); - response["signerDid"] = QString::fromStdString(sigResult.signer_did); - if (!sigResult.signer_name.empty()) { - response["signerName"] = QString::fromStdString(sigResult.signer_name); - } - if (!sigResult.signer_url.empty()) { - response["signerUrl"] = QString::fromStdString(sigResult.signer_url); - } - if (!sigResult.trusted_as.empty()) { - response["trustedAs"] = QString::fromStdString(sigResult.trusted_as); - } + bool valid = sigResult.signature_valid && sigResult.package_valid; + response["signatureStatus"] = valid ? std::string("signed") : std::string("invalid"); + response["signerDid"] = sigResult.signer_did; + if (!sigResult.signer_name.empty()) + response["signerName"] = sigResult.signer_name; + if (!sigResult.signer_url.empty()) + response["signerUrl"] = sigResult.signer_url; + if (!sigResult.trusted_as.empty()) + response["trustedAs"] = sigResult.trusted_as; } else if (!sigResult.error.empty()) { - response["signatureStatus"] = QString("error"); - response["signatureError"] = QString::fromStdString(sigResult.error); + response["signatureStatus"] = std::string("error"); + response["signatureError"] = sigResult.error; } else { - response["signatureStatus"] = QString("unsigned"); + response["signatureStatus"] = std::string("unsigned"); } return response; } -void PackageManagerImpl::onPluginFileInstalled(const QString& pluginPath, bool isCoreModule) +LogosList PackageManagerImpl::getInstalledPackages() { - QVariantList eventData; - eventData << pluginPath; - - if (isCoreModule) { - qDebug() << "Emitting corePluginFileInstalled event for:" << pluginPath; - emitEvent("corePluginFileInstalled", eventData); - } else { - qDebug() << "Emitting uiPluginFileInstalled event for:" << pluginPath; - emitEvent("uiPluginFileInstalled", eventData); - } + return LogosList::parse(m_lib->getInstalledPackages()); } -static QVariantList jsonStringToVariantList(const std::string& jsonStr) +LogosList PackageManagerImpl::getInstalledModules() { - QJsonDocument doc = QJsonDocument::fromJson(QByteArray::fromStdString(jsonStr)); - return doc.array().toVariantList(); + return LogosList::parse(m_lib->getInstalledModules()); } -QVariantList PackageManagerImpl::getInstalledPackages() +LogosList PackageManagerImpl::getInstalledUiPlugins() { - return jsonStringToVariantList(m_lib->getInstalledPackages()); + return LogosList::parse(m_lib->getInstalledUiPlugins()); } -QVariantList PackageManagerImpl::getInstalledModules() +std::vector PackageManagerImpl::getValidVariants() { - return jsonStringToVariantList(m_lib->getInstalledModules()); + return PackageManagerLib::platformVariantsToTry(); } -QVariantList PackageManagerImpl::getInstalledUiPlugins() +void PackageManagerImpl::setEmbeddedModulesDirectory(const std::string& dir) { - return jsonStringToVariantList(m_lib->getInstalledUiPlugins()); + m_lib->setEmbeddedModulesDirectory(dir); } -QStringList PackageManagerImpl::getValidVariants() +void PackageManagerImpl::addEmbeddedModulesDirectory(const std::string& dir) { - QStringList result; - for (const auto& v : PackageManagerLib::platformVariantsToTry()) { - result << QString::fromStdString(v); - } - return result; + m_lib->addEmbeddedModulesDirectory(dir); } -void PackageManagerImpl::setEmbeddedModulesDirectory(const QString& dir) +void PackageManagerImpl::setEmbeddedUiPluginsDirectory(const std::string& dir) { - m_lib->setEmbeddedModulesDirectory(dir.toStdString()); + m_lib->setEmbeddedUiPluginsDirectory(dir); } -void PackageManagerImpl::addEmbeddedModulesDirectory(const QString& dir) +void PackageManagerImpl::addEmbeddedUiPluginsDirectory(const std::string& dir) { - m_lib->addEmbeddedModulesDirectory(dir.toStdString()); + m_lib->addEmbeddedUiPluginsDirectory(dir); } -void PackageManagerImpl::setEmbeddedUiPluginsDirectory(const QString& dir) +void PackageManagerImpl::setUserModulesDirectory(const std::string& dir) { - m_lib->setEmbeddedUiPluginsDirectory(dir.toStdString()); + m_lib->setUserModulesDirectory(dir); } -void PackageManagerImpl::addEmbeddedUiPluginsDirectory(const QString& dir) +void PackageManagerImpl::setUserUiPluginsDirectory(const std::string& dir) { - m_lib->addEmbeddedUiPluginsDirectory(dir.toStdString()); + m_lib->setUserUiPluginsDirectory(dir); } -void PackageManagerImpl::setUserModulesDirectory(const QString& dir) +void PackageManagerImpl::setSignaturePolicy(const std::string& policy) { - m_lib->setUserModulesDirectory(dir.toStdString()); -} - -void PackageManagerImpl::setUserUiPluginsDirectory(const QString& dir) -{ - m_lib->setUserUiPluginsDirectory(dir.toStdString()); -} - -void PackageManagerImpl::setSignaturePolicy(const QString& policy) -{ - std::string p = policy.toLower().toStdString(); + std::string p = policy; + std::transform(p.begin(), p.end(), p.begin(), ::tolower); if (p == "none") m_lib->setSignaturePolicy(SignaturePolicy::NONE); else if (p == "warn") m_lib->setSignaturePolicy(SignaturePolicy::WARN); else if (p == "require") m_lib->setSignaturePolicy(SignaturePolicy::REQUIRE); else { - qWarning() << "PackageManagerImpl::setSignaturePolicy: invalid policy" - << policy << "- expected one of: none, warn, require"; + std::cerr << "PackageManagerImpl::setSignaturePolicy: invalid policy '" + << policy << "' - expected one of: none, warn, require\n"; } } -void PackageManagerImpl::setKeyringDirectory(const QString& dir) +void PackageManagerImpl::setKeyringDirectory(const std::string& dir) { - m_lib->setKeyringDirectory(dir.toStdString()); + m_lib->setKeyringDirectory(dir); } -QVariantMap PackageManagerImpl::verifyPackage(const QString& lgxPath) +LogosMap PackageManagerImpl::verifyPackage(const std::string& lgxPath) { - auto result = m_lib->verifyPackageSignature(lgxPath.toStdString()); + auto result = m_lib->verifyPackageSignature(lgxPath); - QVariantMap response; + LogosMap response; response["isSigned"] = result.is_signed; response["signatureValid"] = result.signature_valid; response["packageValid"] = result.package_valid; - response["signerDid"] = QString::fromStdString(result.signer_did); - response["signerName"] = QString::fromStdString(result.signer_name); - response["signerUrl"] = QString::fromStdString(result.signer_url); - response["trustedAs"] = QString::fromStdString(result.trusted_as); - if (!result.error.empty()) { - response["error"] = QString::fromStdString(result.error); - } + response["signerDid"] = result.signer_did; + response["signerName"] = result.signer_name; + response["signerUrl"] = result.signer_url; + response["trustedAs"] = result.trusted_as; + if (!result.error.empty()) + response["error"] = result.error; return response; } -QVariantMap PackageManagerImpl::addTrustedKey(const QString& name, const QString& did, - const QString& displayName, const QString& url) +LogosMap PackageManagerImpl::addTrustedKey(const std::string& name, const std::string& did, + const std::string& displayName, const std::string& url) { std::string keyringDir = m_lib->keyringDirectory(); const char* keyringDirPtr = keyringDir.empty() ? nullptr : keyringDir.c_str(); - lgx_result_t result = lgx_keyring_add( + lgx_result_t res = lgx_keyring_add( keyringDirPtr, - name.toStdString().c_str(), - did.toStdString().c_str(), - displayName.isEmpty() ? nullptr : displayName.toStdString().c_str(), - url.isEmpty() ? nullptr : url.toStdString().c_str() + name.c_str(), + did.c_str(), + displayName.empty() ? nullptr : displayName.c_str(), + url.empty() ? nullptr : url.c_str() ); - QVariantMap response; - response["success"] = result.success; - if (!result.success && result.error) { - response["error"] = QString::fromUtf8(result.error); - } + LogosMap response; + response["success"] = static_cast(res.success); + if (!res.success && res.error) + response["error"] = std::string(res.error); return response; } -QVariantMap PackageManagerImpl::removeTrustedKey(const QString& name) +LogosMap PackageManagerImpl::removeTrustedKey(const std::string& name) { std::string keyringDir = m_lib->keyringDirectory(); const char* keyringDirPtr = keyringDir.empty() ? nullptr : keyringDir.c_str(); - lgx_result_t result = lgx_keyring_remove( + lgx_result_t res = lgx_keyring_remove( keyringDirPtr, - name.toStdString().c_str() + name.c_str() ); - QVariantMap response; - response["success"] = result.success; - if (!result.success && result.error) { - response["error"] = QString::fromUtf8(result.error); - } + LogosMap response; + response["success"] = static_cast(res.success); + if (!res.success && res.error) + response["error"] = std::string(res.error); return response; } -QVariantList PackageManagerImpl::listTrustedKeys() +LogosList PackageManagerImpl::listTrustedKeys() { std::string keyringDir = m_lib->keyringDirectory(); const char* keyringDirPtr = keyringDir.empty() ? nullptr : keyringDir.c_str(); lgx_keyring_list_t list = lgx_keyring_list(keyringDirPtr); - QVariantList result; + LogosList result = LogosList::array(); for (size_t i = 0; i < list.count; ++i) { - QVariantMap entry; - if (list.keys[i].name) entry["name"] = QString::fromUtf8(list.keys[i].name); - if (list.keys[i].did) entry["did"] = QString::fromUtf8(list.keys[i].did); - if (list.keys[i].display_name) entry["displayName"] = QString::fromUtf8(list.keys[i].display_name); - if (list.keys[i].url) entry["url"] = QString::fromUtf8(list.keys[i].url); - if (list.keys[i].added_at) entry["addedAt"] = QString::fromUtf8(list.keys[i].added_at); - result.append(entry); + LogosMap entry; + if (list.keys[i].name) entry["name"] = std::string(list.keys[i].name); + if (list.keys[i].did) entry["did"] = std::string(list.keys[i].did); + if (list.keys[i].display_name) entry["displayName"] = std::string(list.keys[i].display_name); + if (list.keys[i].url) entry["url"] = std::string(list.keys[i].url); + if (list.keys[i].added_at) entry["addedAt"] = std::string(list.keys[i].added_at); + result.push_back(entry); } lgx_free_keyring_list(list); diff --git a/src/package_manager_impl.h b/src/package_manager_impl.h index 88fa896..8242cf1 100644 --- a/src/package_manager_impl.h +++ b/src/package_manager_impl.h @@ -1,60 +1,55 @@ #pragma once -#include "logos_provider_object.h" -#include "logos_api.h" -#include -#include -#include +#include +#include +#include +#include class PackageManagerLib; -class PackageManagerImpl : public LogosProviderBase -{ - LOGOS_PROVIDER(PackageManagerImpl, "package_manager", "1.0.0") - -protected: - void onInit(LogosAPI* api) override; - +class PackageManagerImpl { public: PackageManagerImpl(); ~PackageManagerImpl(); - // Install from local LGX file — returns QVariantMap {name, path, error, isCoreModule} - LOGOS_METHOD QVariantMap installPlugin(const QString& pluginPath, bool skipIfNotNewerVersion); + // Event callback — wired automatically by the generated glue layer. + // Call this to emit named events to other modules / the host application. + std::function emitEvent; + + // Install from local LGX file — returns LogosMap {name, path, error, isCoreModule, ...} + LogosMap installPlugin(const std::string& pluginPath, bool skipIfNotNewerVersion); // Directory configuration — embedded (multiple, read-only) - LOGOS_METHOD void setEmbeddedModulesDirectory(const QString& dir); - LOGOS_METHOD void addEmbeddedModulesDirectory(const QString& dir); - LOGOS_METHOD void setEmbeddedUiPluginsDirectory(const QString& dir); - LOGOS_METHOD void addEmbeddedUiPluginsDirectory(const QString& dir); + void setEmbeddedModulesDirectory(const std::string& dir); + void addEmbeddedModulesDirectory(const std::string& dir); + void setEmbeddedUiPluginsDirectory(const std::string& dir); + void addEmbeddedUiPluginsDirectory(const std::string& dir); // Directory configuration — user (single, writable) - LOGOS_METHOD void setUserModulesDirectory(const QString& dir); - LOGOS_METHOD void setUserUiPluginsDirectory(const QString& dir); + void setUserModulesDirectory(const std::string& dir); + void setUserUiPluginsDirectory(const std::string& dir); - // Scanning — each returns JSON array with all manifest fields + installDir + mainFilePath - LOGOS_METHOD QVariantList getInstalledPackages(); - LOGOS_METHOD QVariantList getInstalledModules(); - LOGOS_METHOD QVariantList getInstalledUiPlugins(); + // Scanning — each returns LogosList (JSON array with all manifest fields + installDir + mainFilePath) + LogosList getInstalledPackages(); + LogosList getInstalledModules(); + LogosList getInstalledUiPlugins(); // Platform variants this build accepts (e.g. ["darwin-arm64-dev"] or ["darwin-arm64"]) - LOGOS_METHOD QStringList getValidVariants(); + std::vector getValidVariants(); // Signature policy configuration - LOGOS_METHOD void setSignaturePolicy(const QString& policy); - LOGOS_METHOD void setKeyringDirectory(const QString& dir); + void setSignaturePolicy(const std::string& policy); + void setKeyringDirectory(const std::string& dir); - // Standalone signature verification — returns {isSigned, signatureValid, packageValid, signerDid, signerName, signerUrl, trustedAs, error} - LOGOS_METHOD QVariantMap verifyPackage(const QString& lgxPath); + // Standalone signature verification — returns {isSigned, signatureValid, packageValid, signerDid, ...} + LogosMap verifyPackage(const std::string& lgxPath); // Keyring management — add/remove/list trusted signing keys - LOGOS_METHOD QVariantMap addTrustedKey(const QString& name, const QString& did, - const QString& displayName, const QString& url); - LOGOS_METHOD QVariantMap removeTrustedKey(const QString& name); - LOGOS_METHOD QVariantList listTrustedKeys(); + LogosMap addTrustedKey(const std::string& name, const std::string& did, + const std::string& displayName, const std::string& url); + LogosMap removeTrustedKey(const std::string& name); + LogosList listTrustedKeys(); private: PackageManagerLib* m_lib; - - void onPluginFileInstalled(const QString& pluginPath, bool isCoreModule); }; diff --git a/src/package_manager_loader.h b/src/package_manager_loader.h deleted file mode 100644 index 4259ff8..0000000 --- a/src/package_manager_loader.h +++ /dev/null @@ -1,18 +0,0 @@ -#pragma once - -#include -#include "interface.h" -#include "logos_provider_object.h" -#include "package_manager_impl.h" - -class PackageManagerLoader : public QObject, public PluginInterface, public LogosProviderPlugin -{ - Q_OBJECT - Q_PLUGIN_METADATA(IID LogosProviderPlugin_iid FILE "metadata.json") - Q_INTERFACES(PluginInterface LogosProviderPlugin) - -public: - QString name() const override { return "package_manager"; } - QString version() const override { return "1.0.0"; } - LogosProviderObject* createProviderObject() override { return new PackageManagerImpl(); } -}; diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt index f0644c2..60b44ce 100644 --- a/tests/CMakeLists.txt +++ b/tests/CMakeLists.txt @@ -16,10 +16,6 @@ logos_test( mocks/mock_lgx.cpp EXTRA_INCLUDES stubs - GENERATED_SOURCES - ../generated_code/logos_provider_dispatch.cpp - GENERATED_DIR - ../generated_code ) # Integration tests (real PackageManagerLib + lgx) @@ -62,10 +58,6 @@ if(LIBPM_PATH) ../lib EXTRA_LINK_LIBS ${_pm_integration_libs} - GENERATED_SOURCES - ../generated_code/logos_provider_dispatch.cpp - GENERATED_DIR - ../generated_code ) set(_rpath_dirs "") diff --git a/tests/test_directory_config.cpp b/tests/test_directory_config.cpp index 7a61cf2..6ce2b81 100644 --- a/tests/test_directory_config.cpp +++ b/tests/test_directory_config.cpp @@ -9,18 +9,14 @@ // ============================================================================= LOGOS_TEST(set_embedded_modules_directory) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); impl.setEmbeddedModulesDirectory("/some/path"); // No crash, no error — method delegates to underlying lib } LOGOS_TEST(add_embedded_modules_directory) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); impl.setEmbeddedModulesDirectory("/first"); impl.addEmbeddedModulesDirectory("/second"); @@ -31,17 +27,13 @@ LOGOS_TEST(add_embedded_modules_directory) { // ============================================================================= LOGOS_TEST(set_embedded_ui_plugins_directory) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); impl.setEmbeddedUiPluginsDirectory("/ui/path"); } LOGOS_TEST(add_embedded_ui_plugins_directory) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); impl.setEmbeddedUiPluginsDirectory("/ui/first"); impl.addEmbeddedUiPluginsDirectory("/ui/second"); @@ -52,17 +44,13 @@ LOGOS_TEST(add_embedded_ui_plugins_directory) { // ============================================================================= LOGOS_TEST(set_user_modules_directory) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); impl.setUserModulesDirectory("/user/modules"); } LOGOS_TEST(set_user_ui_plugins_directory) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); impl.setUserUiPluginsDirectory("/user/ui"); } @@ -72,31 +60,25 @@ LOGOS_TEST(set_user_ui_plugins_directory) { // ============================================================================= LOGOS_TEST(get_valid_variants_returns_nonempty) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - QStringList variants = impl.getValidVariants(); - LOGOS_ASSERT_FALSE(variants.isEmpty()); - // Each variant should be a non-empty string + std::vector variants = impl.getValidVariants(); + LOGOS_ASSERT_FALSE(variants.empty()); for (const auto& v : variants) { - LOGOS_ASSERT_FALSE(v.isEmpty()); + LOGOS_ASSERT_FALSE(v.empty()); } } LOGOS_TEST(get_valid_variants_contains_platform) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - QStringList variants = impl.getValidVariants(); - // Should contain the current platform (possibly with -dev suffix) + std::vector variants = impl.getValidVariants(); bool hasPlatform = false; for (const auto& v : variants) { #if defined(__APPLE__) - if (v.contains("darwin")) hasPlatform = true; + if (v.find("darwin") != std::string::npos) hasPlatform = true; #elif defined(__linux__) - if (v.contains("linux")) hasPlatform = true; + if (v.find("linux") != std::string::npos) hasPlatform = true; #endif } LOGOS_ASSERT_TRUE(hasPlatform); diff --git a/tests/test_keyring.cpp b/tests/test_keyring.cpp index 82eca40..19b5ae7 100644 --- a/tests/test_keyring.cpp +++ b/tests/test_keyring.cpp @@ -8,26 +8,24 @@ #include #include #include +#include /** * Helper: read DID from a .did file. */ -static QString readDid(const QString& keysDir, const QString& keyName) { +static std::string readDid(const QString& keysDir, const QString& keyName) { QFile f(keysDir + "/" + keyName + ".did"); if (!f.open(QIODevice::ReadOnly)) return {}; - return QString::fromUtf8(f.readAll()).trimmed(); + return QString::fromUtf8(f.readAll()).trimmed().toStdString(); } /** * Helper: generate a keypair and return the DID. */ -static QString generateKeyAndGetDid(const QString& keysDir, const QString& keyName) { +static std::string generateKeyAndGetDid(const QString& keysDir, const QString& keyName) { lgx_result_t res = lgx_keygen(keyName.toStdString().c_str(), keysDir.toStdString().c_str()); if (!res.success) return {}; - - QFile f(keysDir + "/" + keyName + ".did"); - if (!f.open(QIODevice::ReadOnly)) return {}; - return QString::fromUtf8(f.readAll()).trimmed(); + return readDid(keysDir, keyName); } // ============================================================================= @@ -35,9 +33,7 @@ static QString generateKeyAndGetDid(const QString& keysDir, const QString& keyNa // ============================================================================= LOGOS_TEST(add_trusted_key_success) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -47,19 +43,17 @@ LOGOS_TEST(add_trusted_key_success) { QDir().mkpath(keysDir); QDir().mkpath(keyringDir); - impl.setKeyringDirectory(keyringDir); + impl.setKeyringDirectory(keyringDir.toStdString()); - QString did = generateKeyAndGetDid(keysDir, "addkey"); - LOGOS_ASSERT_FALSE(did.isEmpty()); + std::string did = generateKeyAndGetDid(keysDir, "addkey"); + LOGOS_ASSERT_FALSE(did.empty()); - QVariantMap result = impl.addTrustedKey("publisher", did, "Test Publisher", "https://test.com"); - LOGOS_ASSERT_TRUE(result["success"].toBool()); + LogosMap result = impl.addTrustedKey("publisher", did, "Test Publisher", "https://test.com"); + LOGOS_ASSERT_TRUE(result["success"].get()); } LOGOS_TEST(add_trusted_key_invalid_did) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -67,10 +61,10 @@ LOGOS_TEST(add_trusted_key_invalid_did) { QString keyringDir = tmpDir.path() + "/keyring"; QDir().mkpath(keyringDir); - impl.setKeyringDirectory(keyringDir); + impl.setKeyringDirectory(keyringDir.toStdString()); - QVariantMap result = impl.addTrustedKey("bad", "not-a-did", "", ""); - LOGOS_ASSERT_FALSE(result["success"].toBool()); + LogosMap result = impl.addTrustedKey("bad", "not-a-did", "", ""); + LOGOS_ASSERT_FALSE(result["success"].get()); LOGOS_ASSERT_TRUE(result.contains("error")); } @@ -79,9 +73,7 @@ LOGOS_TEST(add_trusted_key_invalid_did) { // ============================================================================= LOGOS_TEST(remove_trusted_key_success) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -91,23 +83,21 @@ LOGOS_TEST(remove_trusted_key_success) { QDir().mkpath(keysDir); QDir().mkpath(keyringDir); - impl.setKeyringDirectory(keyringDir); + impl.setKeyringDirectory(keyringDir.toStdString()); - QString did = generateKeyAndGetDid(keysDir, "rmkey"); - LOGOS_ASSERT_FALSE(did.isEmpty()); + std::string did = generateKeyAndGetDid(keysDir, "rmkey"); + LOGOS_ASSERT_FALSE(did.empty()); // Add then remove - QVariantMap addResult = impl.addTrustedKey("to-remove", did, "", ""); - LOGOS_ASSERT_TRUE(addResult["success"].toBool()); + LogosMap addResult = impl.addTrustedKey("to-remove", did, "", ""); + LOGOS_ASSERT_TRUE(addResult["success"].get()); - QVariantMap rmResult = impl.removeTrustedKey("to-remove"); - LOGOS_ASSERT_TRUE(rmResult["success"].toBool()); + LogosMap rmResult = impl.removeTrustedKey("to-remove"); + LOGOS_ASSERT_TRUE(rmResult["success"].get()); } LOGOS_TEST(remove_nonexistent_key) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -115,10 +105,10 @@ LOGOS_TEST(remove_nonexistent_key) { QString keyringDir = tmpDir.path() + "/keyring"; QDir().mkpath(keyringDir); - impl.setKeyringDirectory(keyringDir); + impl.setKeyringDirectory(keyringDir.toStdString()); - QVariantMap result = impl.removeTrustedKey("does-not-exist"); - LOGOS_ASSERT_FALSE(result["success"].toBool()); + LogosMap result = impl.removeTrustedKey("does-not-exist"); + LOGOS_ASSERT_FALSE(result["success"].get()); } // ============================================================================= @@ -126,9 +116,7 @@ LOGOS_TEST(remove_nonexistent_key) { // ============================================================================= LOGOS_TEST(list_trusted_keys_empty) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -136,16 +124,14 @@ LOGOS_TEST(list_trusted_keys_empty) { QString keyringDir = tmpDir.path() + "/keyring"; QDir().mkpath(keyringDir); - impl.setKeyringDirectory(keyringDir); + impl.setKeyringDirectory(keyringDir.toStdString()); - QVariantList keys = impl.listTrustedKeys(); - LOGOS_ASSERT_EQ(keys.size(), 0); + LogosList keys = impl.listTrustedKeys(); + LOGOS_ASSERT_EQ(keys.size(), static_cast(0)); } LOGOS_TEST(list_trusted_keys_after_add) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -155,32 +141,30 @@ LOGOS_TEST(list_trusted_keys_after_add) { QDir().mkpath(keysDir); QDir().mkpath(keyringDir); - impl.setKeyringDirectory(keyringDir); + impl.setKeyringDirectory(keyringDir.toStdString()); - QString did1 = generateKeyAndGetDid(keysDir, "listkey1"); - QString did2 = generateKeyAndGetDid(keysDir, "listkey2"); - LOGOS_ASSERT_FALSE(did1.isEmpty()); - LOGOS_ASSERT_FALSE(did2.isEmpty()); + std::string did1 = generateKeyAndGetDid(keysDir, "listkey1"); + std::string did2 = generateKeyAndGetDid(keysDir, "listkey2"); + LOGOS_ASSERT_FALSE(did1.empty()); + LOGOS_ASSERT_FALSE(did2.empty()); impl.addTrustedKey("key-one", did1, "Publisher One", "https://one.com"); impl.addTrustedKey("key-two", did2, "Publisher Two", ""); - QVariantList keys = impl.listTrustedKeys(); - LOGOS_ASSERT_EQ(keys.size(), 2); + LogosList keys = impl.listTrustedKeys(); + LOGOS_ASSERT_EQ(keys.size(), static_cast(2)); // Collect names - QStringList names; + std::vector names; for (const auto& key : keys) { - names << key.toMap()["name"].toString(); + names.push_back(key["name"].get()); } - LOGOS_ASSERT_TRUE(names.contains("key-one")); - LOGOS_ASSERT_TRUE(names.contains("key-two")); + LOGOS_ASSERT_TRUE(std::find(names.begin(), names.end(), "key-one") != names.end()); + LOGOS_ASSERT_TRUE(std::find(names.begin(), names.end(), "key-two") != names.end()); } LOGOS_TEST(list_trusted_keys_contains_metadata) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -190,22 +174,22 @@ LOGOS_TEST(list_trusted_keys_contains_metadata) { QDir().mkpath(keysDir); QDir().mkpath(keyringDir); - impl.setKeyringDirectory(keyringDir); + impl.setKeyringDirectory(keyringDir.toStdString()); - QString did = generateKeyAndGetDid(keysDir, "metakey"); - LOGOS_ASSERT_FALSE(did.isEmpty()); + std::string did = generateKeyAndGetDid(keysDir, "metakey"); + LOGOS_ASSERT_FALSE(did.empty()); impl.addTrustedKey("meta-publisher", did, "Test Name", "https://test.com"); - QVariantList keys = impl.listTrustedKeys(); - LOGOS_ASSERT_EQ(keys.size(), 1); + LogosList keys = impl.listTrustedKeys(); + LOGOS_ASSERT_EQ(keys.size(), static_cast(1)); - QVariantMap key = keys[0].toMap(); - LOGOS_ASSERT_EQ(key["name"].toString(), QString("meta-publisher")); - LOGOS_ASSERT_EQ(key["did"].toString(), did); - LOGOS_ASSERT_EQ(key["displayName"].toString(), QString("Test Name")); - LOGOS_ASSERT_EQ(key["url"].toString(), QString("https://test.com")); - LOGOS_ASSERT_FALSE(key["addedAt"].toString().isEmpty()); + LogosMap key = keys[0]; + LOGOS_ASSERT_EQ(key["name"].get(), std::string("meta-publisher")); + LOGOS_ASSERT_EQ(key["did"].get(), did); + LOGOS_ASSERT_EQ(key["displayName"].get(), std::string("Test Name")); + LOGOS_ASSERT_EQ(key["url"].get(), std::string("https://test.com")); + LOGOS_ASSERT_FALSE(key["addedAt"].get().empty()); } // ============================================================================= @@ -213,9 +197,7 @@ LOGOS_TEST(list_trusted_keys_contains_metadata) { // ============================================================================= LOGOS_TEST(keyring_add_then_verify_trusted) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -225,7 +207,7 @@ LOGOS_TEST(keyring_add_then_verify_trusted) { QDir().mkpath(keysDir); QDir().mkpath(keyringDir); - impl.setKeyringDirectory(keyringDir); + impl.setKeyringDirectory(keyringDir.toStdString()); // Create and sign a package QString lgxPath = tmpDir.path() + "/rt_test.lgx"; @@ -243,12 +225,12 @@ LOGOS_TEST(keyring_add_then_verify_trusted) { lgx_package_t pkg = lgx_load(lgxPath.toStdString().c_str()); lgx_set_version(pkg, "1.0.0"); - QString variant = [] { + std::string variant = [] { auto v = PackageManagerLib::platformVariantsToTry(); - return v.empty() ? "unknown" : QString::fromStdString(v.front()); + return v.empty() ? std::string("unknown") : v.front(); }(); - lgx_add_variant(pkg, variant.toStdString().c_str(), + lgx_add_variant(pkg, variant.c_str(), contentDir.toStdString().c_str(), libName.toStdString().c_str()); lgx_save(pkg, lgxPath.toStdString().c_str()); @@ -260,18 +242,17 @@ LOGOS_TEST(keyring_add_then_verify_trusted) { lgx_sign(lgxPath.toStdString().c_str(), keyPath.toStdString().c_str(), nullptr, nullptr); // Verify: not yet trusted - QVariantMap r1 = impl.verifyPackage(lgxPath); - LOGOS_ASSERT_TRUE(r1["isSigned"].toBool()); - LOGOS_ASSERT_TRUE(r1["signatureValid"].toBool()); - LOGOS_ASSERT_TRUE(r1["trustedAs"].toString().isEmpty()); + LogosMap r1 = impl.verifyPackage(lgxPath.toStdString()); + LOGOS_ASSERT_TRUE(r1["isSigned"].get()); + LOGOS_ASSERT_TRUE(r1["signatureValid"].get()); + LOGOS_ASSERT_TRUE(r1["trustedAs"].get().empty()); // Trust the key - QString did = readDid(keysDir, "rtkey"); + std::string did = readDid(keysDir, "rtkey"); impl.addTrustedKey("rt-publisher", did, "", ""); // Verify: now trusted - QVariantMap r2 = impl.verifyPackage(lgxPath); - LOGOS_ASSERT_TRUE(r2["isSigned"].toBool()); - LOGOS_ASSERT_EQ(r2["trustedAs"].toString(), QString("rt-publisher")); + LogosMap r2 = impl.verifyPackage(lgxPath.toStdString()); + LOGOS_ASSERT_TRUE(r2["isSigned"].get()); + LOGOS_ASSERT_EQ(r2["trustedAs"].get(), std::string("rt-publisher")); } - diff --git a/tests/test_package_manager.cpp b/tests/test_package_manager.cpp index 6f69cfc..d2dff44 100644 --- a/tests/test_package_manager.cpp +++ b/tests/test_package_manager.cpp @@ -3,70 +3,71 @@ #include #include "package_manager_impl.h" -#include +#include LOGOS_TEST(onInit_does_not_throw) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); LOGOS_ASSERT_FALSE(t.moduleCalled("any_module", "any_method")); } LOGOS_TEST(installPlugin_success_core_emits_core_event) { auto t = LogosTestContext("package_manager"); - t.captureEvents(); t.mockCFunction("installPluginFile_result").returns("/installed/core.dylib"); t.mockCFunction("installPluginFile_installedPath").returns("/installed/core.dylib"); t.mockCFunction("installPluginFile_error").returns(""); t.mockCFunction("installPluginFile_isCore").returns(true); + std::string lastEvent; + std::string lastEventData; PackageManagerImpl impl; - t.init(&impl); + impl.emitEvent = [&](const std::string& name, const std::string& data) { + lastEvent = name; + lastEventData = data; + }; - QVariantMap m = impl.installPlugin(QStringLiteral("/path/to/foo.lgx"), false); - LOGOS_ASSERT_EQ(m[QStringLiteral("path")].toString(), QStringLiteral("/installed/core.dylib")); - LOGOS_ASSERT_TRUE(m[QStringLiteral("isCoreModule")].toBool()); - LOGOS_ASSERT_FALSE(m.contains(QStringLiteral("error"))); - LOGOS_ASSERT_EQ(m[QStringLiteral("name")].toString(), QStringLiteral("foo")); - LOGOS_ASSERT_EQ(m[QStringLiteral("signatureStatus")].toString(), QStringLiteral("unsigned")); + LogosMap m = impl.installPlugin("/path/to/foo.lgx", false); + LOGOS_ASSERT_EQ(m["path"].get(), std::string("/installed/core.dylib")); + LOGOS_ASSERT_TRUE(m["isCoreModule"].get()); + LOGOS_ASSERT_FALSE(m.contains("error")); + LOGOS_ASSERT_EQ(m["name"].get(), std::string("foo")); + LOGOS_ASSERT_EQ(m["signatureStatus"].get(), std::string("unsigned")); LOGOS_ASSERT_TRUE(t.cFunctionCalled("verifyPackageSignature")); - LOGOS_ASSERT_TRUE(t.eventEmitted("corePluginFileInstalled")); - LOGOS_ASSERT_FALSE(t.eventEmitted("uiPluginFileInstalled")); + LOGOS_ASSERT_EQ(lastEvent, std::string("corePluginFileInstalled")); + LOGOS_ASSERT_EQ(lastEventData, std::string("/installed/core.dylib")); LOGOS_ASSERT_TRUE(t.cFunctionCalled("installPluginFile")); } LOGOS_TEST(installPlugin_success_ui_emits_ui_event) { auto t = LogosTestContext("package_manager"); - t.captureEvents(); t.mockCFunction("installPluginFile_result").returns("/ui/plugin.qml"); t.mockCFunction("installPluginFile_installedPath").returns("/ui/plugin.qml"); t.mockCFunction("installPluginFile_error").returns(""); t.mockCFunction("installPluginFile_isCore").returns(false); + std::string lastEvent; PackageManagerImpl impl; - t.init(&impl); + impl.emitEvent = [&](const std::string& name, const std::string&) { lastEvent = name; }; - QVariantMap m = impl.installPlugin(QStringLiteral("/path/bar.lgx"), false); - LOGOS_ASSERT_FALSE(m[QStringLiteral("isCoreModule")].toBool()); - LOGOS_ASSERT_TRUE(t.eventEmitted("uiPluginFileInstalled")); - LOGOS_ASSERT_FALSE(t.eventEmitted("corePluginFileInstalled")); + LogosMap m = impl.installPlugin("/path/bar.lgx", false); + LOGOS_ASSERT_FALSE(m["isCoreModule"].get()); + LOGOS_ASSERT_EQ(lastEvent, std::string("uiPluginFileInstalled")); } LOGOS_TEST(installPlugin_failure_sets_error_no_event) { auto t = LogosTestContext("package_manager"); - t.captureEvents(); t.mockCFunction("installPluginFile_result").returns(""); t.mockCFunction("installPluginFile_error").returns("invalid lgx"); t.mockCFunction("installPluginFile_installedPath").returns(""); + std::string lastEvent; PackageManagerImpl impl; - t.init(&impl); + impl.emitEvent = [&](const std::string& name, const std::string&) { lastEvent = name; }; - QVariantMap m = impl.installPlugin(QStringLiteral("/bad.lgx"), false); - LOGOS_ASSERT_TRUE(m[QStringLiteral("path")].toString().isEmpty()); - LOGOS_ASSERT_EQ(m[QStringLiteral("error")].toString(), QStringLiteral("invalid lgx")); - LOGOS_ASSERT_FALSE(t.eventEmitted("corePluginFileInstalled")); - LOGOS_ASSERT_FALSE(t.eventEmitted("uiPluginFileInstalled")); + LogosMap m = impl.installPlugin("/bad.lgx", false); + LOGOS_ASSERT_TRUE(m["path"].get().empty()); + LOGOS_ASSERT_EQ(m["error"].get(), std::string("invalid lgx")); + LOGOS_ASSERT_TRUE(lastEvent.empty()); } LOGOS_TEST(installPlugin_skipIfNotNewerVersion_passed_to_mock) { @@ -76,60 +77,53 @@ LOGOS_TEST(installPlugin_skipIfNotNewerVersion_passed_to_mock) { t.mockCFunction("installPluginFile_error").returns(""); PackageManagerImpl impl; - t.init(&impl); - impl.installPlugin(QStringLiteral("/x.lgx"), true); + impl.installPlugin("/x.lgx", true); LOGOS_ASSERT_TRUE(t.cFunctionCalled("installPluginFile_skipIfNotNewer_true")); - impl.installPlugin(QStringLiteral("/y.lgx"), false); + impl.installPlugin("/y.lgx", false); LOGOS_ASSERT_TRUE(t.cFunctionCalled("installPluginFile_skipIfNotNewer_false")); } LOGOS_TEST(setEmbeddedModulesDirectory_forwards_to_lib) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - impl.setEmbeddedModulesDirectory(QStringLiteral("/emb/mod")); + impl.setEmbeddedModulesDirectory("/emb/mod"); LOGOS_ASSERT_TRUE(t.cFunctionCalled("setEmbeddedModulesDirectory")); } LOGOS_TEST(addEmbeddedModulesDirectory_forwards_to_lib) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - impl.addEmbeddedModulesDirectory(QStringLiteral("/emb/m2")); + impl.addEmbeddedModulesDirectory("/emb/m2"); LOGOS_ASSERT_TRUE(t.cFunctionCalled("addEmbeddedModulesDirectory")); } LOGOS_TEST(setEmbeddedUiPluginsDirectory_forwards_to_lib) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - impl.setEmbeddedUiPluginsDirectory(QStringLiteral("/emb/ui")); + impl.setEmbeddedUiPluginsDirectory("/emb/ui"); LOGOS_ASSERT_TRUE(t.cFunctionCalled("setEmbeddedUiPluginsDirectory")); } LOGOS_TEST(addEmbeddedUiPluginsDirectory_forwards_to_lib) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - impl.addEmbeddedUiPluginsDirectory(QStringLiteral("/emb/ui2")); + impl.addEmbeddedUiPluginsDirectory("/emb/ui2"); LOGOS_ASSERT_TRUE(t.cFunctionCalled("addEmbeddedUiPluginsDirectory")); } LOGOS_TEST(setUserModulesDirectory_forwards_to_lib) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - impl.setUserModulesDirectory(QStringLiteral("/user/mod")); + impl.setUserModulesDirectory("/user/mod"); LOGOS_ASSERT_TRUE(t.cFunctionCalled("setUserModulesDirectory")); } LOGOS_TEST(setUserUiPluginsDirectory_forwards_to_lib) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - impl.setUserUiPluginsDirectory(QStringLiteral("/user/ui")); + impl.setUserUiPluginsDirectory("/user/ui"); LOGOS_ASSERT_TRUE(t.cFunctionCalled("setUserUiPluginsDirectory")); } @@ -138,12 +132,10 @@ LOGOS_TEST(getInstalledPackages_parses_json_array) { t.mockCFunction("getInstalledPackages").returns(R"([{"name":"pkg1","version":"1.0.0"}])"); PackageManagerImpl impl; - t.init(&impl); - QVariantList list = impl.getInstalledPackages(); - LOGOS_ASSERT_EQ(list.size(), 1); - QVariantMap row = list[0].toMap(); - LOGOS_ASSERT_EQ(row[QStringLiteral("name")].toString(), QStringLiteral("pkg1")); + LogosList list = impl.getInstalledPackages(); + LOGOS_ASSERT_EQ(list.size(), static_cast(1)); + LOGOS_ASSERT_EQ(list[0]["name"].get(), std::string("pkg1")); LOGOS_ASSERT_TRUE(t.cFunctionCalled("getInstalledPackages")); } @@ -152,11 +144,10 @@ LOGOS_TEST(getInstalledModules_parses_json) { t.mockCFunction("getInstalledModules").returns(R"([{"name":"mod_a"}])"); PackageManagerImpl impl; - t.init(&impl); - QVariantList list = impl.getInstalledModules(); - LOGOS_ASSERT_EQ(list.size(), 1); - LOGOS_ASSERT_EQ(list[0].toMap()[QStringLiteral("name")].toString(), QStringLiteral("mod_a")); + LogosList list = impl.getInstalledModules(); + LOGOS_ASSERT_EQ(list.size(), static_cast(1)); + LOGOS_ASSERT_EQ(list[0]["name"].get(), std::string("mod_a")); } LOGOS_TEST(getInstalledUiPlugins_parses_json) { @@ -164,22 +155,19 @@ LOGOS_TEST(getInstalledUiPlugins_parses_json) { t.mockCFunction("getInstalledUiPlugins").returns(R"([{"name":"ui_z"}])"); PackageManagerImpl impl; - t.init(&impl); - QVariantList list = impl.getInstalledUiPlugins(); - LOGOS_ASSERT_EQ(list.size(), 1); - LOGOS_ASSERT_EQ(list[0].toMap()[QStringLiteral("name")].toString(), QStringLiteral("ui_z")); + LogosList list = impl.getInstalledUiPlugins(); + LOGOS_ASSERT_EQ(list.size(), static_cast(1)); + LOGOS_ASSERT_EQ(list[0]["name"].get(), std::string("ui_z")); } LOGOS_TEST(getInstalledPackages_empty_json_array) { auto t = LogosTestContext("package_manager"); - // Default mock returns "[]" when getInstalledPackages string not set; force explicit t.mockCFunction("getInstalledPackages").returns("[]"); PackageManagerImpl impl; - t.init(&impl); - LOGOS_ASSERT_TRUE(impl.getInstalledPackages().isEmpty()); + LOGOS_ASSERT_TRUE(impl.getInstalledPackages().empty()); } LOGOS_TEST(getValidVariants_uses_platformVariantsToTry) { @@ -187,44 +175,39 @@ LOGOS_TEST(getValidVariants_uses_platformVariantsToTry) { t.mockCFunction("platformVariantsToTry_first").returns("custom-variant"); PackageManagerImpl impl; - t.init(&impl); - QStringList v = impl.getValidVariants(); - LOGOS_ASSERT_EQ(v.size(), 1); - LOGOS_ASSERT_EQ(v[0], QStringLiteral("custom-variant")); + std::vector v = impl.getValidVariants(); + LOGOS_ASSERT_EQ(static_cast(v.size()), 1); + LOGOS_ASSERT_EQ(v[0], std::string("custom-variant")); LOGOS_ASSERT_TRUE(t.cFunctionCalled("platformVariantsToTry")); } LOGOS_TEST(getValidVariants_default_mock_variant) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - QStringList v = impl.getValidVariants(); - LOGOS_ASSERT_FALSE(v.isEmpty()); - LOGOS_ASSERT_EQ(v[0], QStringLiteral("mock-variant")); + std::vector v = impl.getValidVariants(); + LOGOS_ASSERT_FALSE(v.empty()); + LOGOS_ASSERT_EQ(v[0], std::string("mock-variant")); } LOGOS_TEST(no_cross_module_calls_by_default) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); LOGOS_ASSERT_EQ(t.moduleCallCount("capability_module", "requestModule"), 0); } LOGOS_TEST(setSignaturePolicy_forwards_to_lib) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - impl.setSignaturePolicy(QStringLiteral("warn")); + impl.setSignaturePolicy("warn"); LOGOS_ASSERT_TRUE(t.cFunctionCalled("setSignaturePolicy")); } LOGOS_TEST(setKeyringDirectory_forwards_to_lib) { auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); - impl.setKeyringDirectory(QStringLiteral("/kr")); + impl.setKeyringDirectory("/kr"); LOGOS_ASSERT_TRUE(t.cFunctionCalled("setKeyringDirectory")); } @@ -236,12 +219,11 @@ LOGOS_TEST(verifyPackage_maps_signature_result) { t.mockCFunction("verifyPackageSignature_signer_did").returns("did:jwk:test"); PackageManagerImpl impl; - t.init(&impl); - QVariantMap m = impl.verifyPackage(QStringLiteral("/any.lgx")); - LOGOS_ASSERT_TRUE(m[QStringLiteral("isSigned")].toBool()); - LOGOS_ASSERT_TRUE(m[QStringLiteral("signatureValid")].toBool()); - LOGOS_ASSERT_TRUE(m[QStringLiteral("packageValid")].toBool()); - LOGOS_ASSERT_EQ(m[QStringLiteral("signerDid")].toString(), QStringLiteral("did:jwk:test")); + LogosMap m = impl.verifyPackage("/any.lgx"); + LOGOS_ASSERT_TRUE(m["isSigned"].get()); + LOGOS_ASSERT_TRUE(m["signatureValid"].get()); + LOGOS_ASSERT_TRUE(m["packageValid"].get()); + LOGOS_ASSERT_EQ(m["signerDid"].get(), std::string("did:jwk:test")); LOGOS_ASSERT_TRUE(t.cFunctionCalled("verifyPackageSignature")); } diff --git a/tests/test_package_manager_integration.cpp b/tests/test_package_manager_integration.cpp index bc0cece..2cc1b27 100644 --- a/tests/test_package_manager_integration.cpp +++ b/tests/test_package_manager_integration.cpp @@ -9,10 +9,10 @@ LOGOS_TEST(integration_getValidVariants_non_empty) { PackageManagerImpl impl; - QStringList v = impl.getValidVariants(); - LOGOS_ASSERT_FALSE(v.isEmpty()); - for (const QString& s : v) { - LOGOS_ASSERT_FALSE(s.isEmpty()); + std::vector v = impl.getValidVariants(); + LOGOS_ASSERT_FALSE(v.empty()); + for (const auto& s : v) { + LOGOS_ASSERT_FALSE(s.empty()); } } @@ -21,12 +21,12 @@ LOGOS_TEST(integration_empty_user_modules_yields_empty_lists) { LOGOS_ASSERT_TRUE(dir.isValid()); PackageManagerImpl impl; - impl.setUserModulesDirectory(dir.path()); - impl.setUserUiPluginsDirectory(dir.path()); + impl.setUserModulesDirectory(dir.path().toStdString()); + impl.setUserUiPluginsDirectory(dir.path().toStdString()); - LOGOS_ASSERT_TRUE(impl.getInstalledModules().isEmpty()); - LOGOS_ASSERT_TRUE(impl.getInstalledUiPlugins().isEmpty()); - LOGOS_ASSERT_TRUE(impl.getInstalledPackages().isEmpty()); + LOGOS_ASSERT_TRUE(impl.getInstalledModules().empty()); + LOGOS_ASSERT_TRUE(impl.getInstalledUiPlugins().empty()); + LOGOS_ASSERT_TRUE(impl.getInstalledPackages().empty()); } LOGOS_TEST(integration_embedded_directory_scan_empty) { @@ -34,8 +34,8 @@ LOGOS_TEST(integration_embedded_directory_scan_empty) { LOGOS_ASSERT_TRUE(emb.isValid()); PackageManagerImpl impl; - impl.addEmbeddedModulesDirectory(emb.path()); + impl.addEmbeddedModulesDirectory(emb.path().toStdString()); // No packages under an empty embedded dir - LOGOS_ASSERT_TRUE(impl.getInstalledModules().isEmpty()); + LOGOS_ASSERT_TRUE(impl.getInstalledModules().empty()); } diff --git a/tests/test_scanning.cpp b/tests/test_scanning.cpp index 62122b8..8f13ecb 100644 --- a/tests/test_scanning.cpp +++ b/tests/test_scanning.cpp @@ -35,45 +35,39 @@ static void createFakeModule(const QString& baseDir, const QString& name, // ============================================================================= LOGOS_TEST(get_installed_packages_empty_dir) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); - impl.setEmbeddedModulesDirectory(tmpDir.path()); + impl.setEmbeddedModulesDirectory(tmpDir.path().toStdString()); - QVariantList packages = impl.getInstalledPackages(); - LOGOS_ASSERT_EQ(packages.size(), 0); + LogosList packages = impl.getInstalledPackages(); + LOGOS_ASSERT_EQ(packages.size(), static_cast(0)); } LOGOS_TEST(get_installed_modules_empty_dir) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); - impl.setEmbeddedModulesDirectory(tmpDir.path()); + impl.setEmbeddedModulesDirectory(tmpDir.path().toStdString()); - QVariantList modules = impl.getInstalledModules(); - LOGOS_ASSERT_EQ(modules.size(), 0); + LogosList modules = impl.getInstalledModules(); + LOGOS_ASSERT_EQ(modules.size(), static_cast(0)); } LOGOS_TEST(get_installed_ui_plugins_empty_dir) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); - impl.setEmbeddedUiPluginsDirectory(tmpDir.path()); + impl.setEmbeddedUiPluginsDirectory(tmpDir.path().toStdString()); - QVariantList plugins = impl.getInstalledUiPlugins(); - LOGOS_ASSERT_EQ(plugins.size(), 0); + LogosList plugins = impl.getInstalledUiPlugins(); + LOGOS_ASSERT_EQ(plugins.size(), static_cast(0)); } // ============================================================================= @@ -81,9 +75,7 @@ LOGOS_TEST(get_installed_ui_plugins_empty_dir) { // ============================================================================= LOGOS_TEST(get_installed_modules_finds_core_modules) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -91,20 +83,18 @@ LOGOS_TEST(get_installed_modules_finds_core_modules) { createFakeModule(tmpDir.path(), "core_mod", "core"); createFakeModule(tmpDir.path(), "ui_mod", "ui"); - impl.setEmbeddedModulesDirectory(tmpDir.path()); + impl.setEmbeddedModulesDirectory(tmpDir.path().toStdString()); - QVariantList modules = impl.getInstalledModules(); + LogosList modules = impl.getInstalledModules(); // Only core modules should be returned - LOGOS_ASSERT_EQ(modules.size(), 1); + LOGOS_ASSERT_EQ(modules.size(), static_cast(1)); - QVariantMap mod = modules[0].toMap(); - LOGOS_ASSERT_EQ(mod["name"].toString(), QString("core_mod")); + LogosMap mod = modules[0]; + LOGOS_ASSERT_EQ(mod["name"].get(), std::string("core_mod")); } LOGOS_TEST(get_installed_ui_plugins_finds_ui_modules) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -113,17 +103,15 @@ LOGOS_TEST(get_installed_ui_plugins_finds_ui_modules) { createFakeModule(tmpDir.path(), "ui_mod", "ui"); createFakeModule(tmpDir.path(), "qml_mod", "ui_qml"); - impl.setEmbeddedUiPluginsDirectory(tmpDir.path()); + impl.setEmbeddedUiPluginsDirectory(tmpDir.path().toStdString()); - QVariantList plugins = impl.getInstalledUiPlugins(); + LogosList plugins = impl.getInstalledUiPlugins(); // Should find ui and ui_qml modules - LOGOS_ASSERT_EQ(plugins.size(), 2); + LOGOS_ASSERT_EQ(plugins.size(), static_cast(2)); } LOGOS_TEST(get_installed_packages_returns_all_types) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -132,29 +120,27 @@ LOGOS_TEST(get_installed_packages_returns_all_types) { createFakeModule(tmpDir.path(), "ui_mod", "ui"); createFakeModule(tmpDir.path(), "qml_mod", "ui_qml"); - impl.setEmbeddedModulesDirectory(tmpDir.path()); + impl.setEmbeddedModulesDirectory(tmpDir.path().toStdString()); - QVariantList packages = impl.getInstalledPackages(); - LOGOS_ASSERT_EQ(packages.size(), 3); + LogosList packages = impl.getInstalledPackages(); + LOGOS_ASSERT_EQ(packages.size(), static_cast(3)); } LOGOS_TEST(scanned_modules_contain_manifest_fields) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); createFakeModule(tmpDir.path(), "test_mod", "core", "2.1.0"); - impl.setEmbeddedModulesDirectory(tmpDir.path()); + impl.setEmbeddedModulesDirectory(tmpDir.path().toStdString()); - QVariantList modules = impl.getInstalledModules(); - LOGOS_ASSERT_EQ(modules.size(), 1); + LogosList modules = impl.getInstalledModules(); + LOGOS_ASSERT_EQ(modules.size(), static_cast(1)); - QVariantMap mod = modules[0].toMap(); - LOGOS_ASSERT_EQ(mod["name"].toString(), QString("test_mod")); - LOGOS_ASSERT_EQ(mod["version"].toString(), QString("2.1.0")); - LOGOS_ASSERT_EQ(mod["type"].toString(), QString("core")); + LogosMap mod = modules[0]; + LOGOS_ASSERT_EQ(mod["name"].get(), std::string("test_mod")); + LOGOS_ASSERT_EQ(mod["version"].get(), std::string("2.1.0")); + LOGOS_ASSERT_EQ(mod["type"].get(), std::string("core")); } diff --git a/tests/test_signature.cpp b/tests/test_signature.cpp index bb2fe26..0754a26 100644 --- a/tests/test_signature.cpp +++ b/tests/test_signature.cpp @@ -12,19 +12,16 @@ /** * Helper to get the preferred platform variant (matches what the library expects). */ -static QString currentVariant() { - QStringList variants; - for (const auto& v : PackageManagerLib::platformVariantsToTry()) { - variants << QString::fromStdString(v); - } - return variants.isEmpty() ? "unknown" : variants.first(); +static std::string currentVariant() { + std::vector variants = PackageManagerLib::platformVariantsToTry(); + return variants.empty() ? "unknown" : variants.front(); } /** * Helper: create a minimal unsigned .lgx package in a temp directory. - * Returns path to the .lgx file. + * Returns path to the .lgx file as std::string. */ -static QString createUnsignedPackage(const QString& dir, const QString& name) { +static std::string createUnsignedPackage(const QString& dir, const QString& name) { QString lgxPath = dir + "/" + name + ".lgx"; QString contentDir = dir + "/" + name + "_content"; QDir().mkpath(contentDir); @@ -57,55 +54,57 @@ static QString createUnsignedPackage(const QString& dir, const QString& name) { } // Create LGX package - lgx_result_t res = lgx_create(lgxPath.toStdString().c_str(), name.toStdString().c_str()); + std::string lgxStd = lgxPath.toStdString(); + std::string nameStd = name.toStdString(); + lgx_result_t res = lgx_create(lgxStd.c_str(), nameStd.c_str()); if (!res.success) return {}; - lgx_package_t pkg = lgx_load(lgxPath.toStdString().c_str()); + lgx_package_t pkg = lgx_load(lgxStd.c_str()); if (!pkg) return {}; lgx_set_version(pkg, "1.0.0"); lgx_set_description(pkg, "Test package"); - std::string variant = currentVariant().toStdString(); + std::string variant = currentVariant(); res = lgx_add_variant(pkg, variant.c_str(), contentDir.toStdString().c_str(), libName.toStdString().c_str()); if (!res.success) { lgx_free_package(pkg); return {}; } - res = lgx_save(pkg, lgxPath.toStdString().c_str()); + res = lgx_save(pkg, lgxStd.c_str()); lgx_free_package(pkg); - return res.success ? lgxPath : QString(); + return res.success ? lgxStd : std::string(); } /** - * Helper: generate a keypair. Returns path to .jwk file. + * Helper: generate a keypair. Returns path to .jwk file as std::string. */ -static QString generateKey(const QString& keysDir, const QString& keyName) { +static std::string generateKey(const QString& keysDir, const QString& keyName) { lgx_result_t res = lgx_keygen(keyName.toStdString().c_str(), keysDir.toStdString().c_str()); if (!res.success) return {}; - return keysDir + "/" + keyName + ".jwk"; + return (keysDir + "/" + keyName + ".jwk").toStdString(); } /** * Helper: read DID from a .did file. */ -static QString readDid(const QString& keysDir, const QString& keyName) { +static std::string readDid(const QString& keysDir, const QString& keyName) { QFile f(keysDir + "/" + keyName + ".did"); if (!f.open(QIODevice::ReadOnly)) return {}; - return QString::fromUtf8(f.readAll()).trimmed(); + return QString::fromUtf8(f.readAll()).trimmed().toStdString(); } /** * Helper: sign a package with a key. */ -static bool signPackage(const QString& lgxPath, const QString& keyPath, - const QString& signerName = {}, const QString& signerUrl = {}) { +static bool signPackage(const std::string& lgxPath, const std::string& keyPath, + const std::string& signerName = {}, const std::string& signerUrl = {}) { lgx_result_t res = lgx_sign( - lgxPath.toStdString().c_str(), - keyPath.toStdString().c_str(), - signerName.isEmpty() ? nullptr : signerName.toStdString().c_str(), - signerUrl.isEmpty() ? nullptr : signerUrl.toStdString().c_str() + lgxPath.c_str(), + keyPath.c_str(), + signerName.empty() ? nullptr : signerName.c_str(), + signerUrl.empty() ? nullptr : signerUrl.c_str() ); return res.success; } @@ -115,9 +114,7 @@ static bool signPackage(const QString& lgxPath, const QString& keyPath, // ============================================================================= LOGOS_TEST(set_signature_policy_none) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); // Should not crash or warn impl.setSignaturePolicy("none"); @@ -126,25 +123,19 @@ LOGOS_TEST(set_signature_policy_none) { } LOGOS_TEST(set_signature_policy_warn) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); impl.setSignaturePolicy("warn"); } LOGOS_TEST(set_signature_policy_require) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); impl.setSignaturePolicy("require"); } LOGOS_TEST(set_keyring_directory) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); impl.setKeyringDirectory("/custom/keyring"); } @@ -154,21 +145,19 @@ LOGOS_TEST(set_keyring_directory) { // ============================================================================= LOGOS_TEST(verify_unsigned_package) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); - QString lgxPath = createUnsignedPackage(tmpDir.path(), "verify_unsigned"); - LOGOS_ASSERT_FALSE(lgxPath.isEmpty()); + std::string lgxPath = createUnsignedPackage(tmpDir.path(), "verify_unsigned"); + LOGOS_ASSERT_FALSE(lgxPath.empty()); - QVariantMap result = impl.verifyPackage(lgxPath); + LogosMap result = impl.verifyPackage(lgxPath); - LOGOS_ASSERT_FALSE(result["isSigned"].toBool()); - LOGOS_ASSERT_FALSE(result["signatureValid"].toBool()); - LOGOS_ASSERT_TRUE(result["signerDid"].toString().isEmpty()); + LOGOS_ASSERT_FALSE(result["isSigned"].get()); + LOGOS_ASSERT_FALSE(result["signatureValid"].get()); + LOGOS_ASSERT_TRUE(result["signerDid"].get().empty()); } // ============================================================================= @@ -176,9 +165,7 @@ LOGOS_TEST(verify_unsigned_package) { // ============================================================================= LOGOS_TEST(verify_signed_package) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -186,24 +173,24 @@ LOGOS_TEST(verify_signed_package) { QString keysDir = tmpDir.path() + "/keys"; QDir().mkpath(keysDir); - QString lgxPath = createUnsignedPackage(tmpDir.path(), "verify_signed"); - LOGOS_ASSERT_FALSE(lgxPath.isEmpty()); + std::string lgxPath = createUnsignedPackage(tmpDir.path(), "verify_signed"); + LOGOS_ASSERT_FALSE(lgxPath.empty()); - QString keyPath = generateKey(keysDir, "testkey"); - LOGOS_ASSERT_FALSE(keyPath.isEmpty()); + std::string keyPath = generateKey(keysDir, "testkey"); + LOGOS_ASSERT_FALSE(keyPath.empty()); LOGOS_ASSERT_TRUE(signPackage(lgxPath, keyPath, "Test Signer", "https://example.com")); - QVariantMap result = impl.verifyPackage(lgxPath); + LogosMap result = impl.verifyPackage(lgxPath); - LOGOS_ASSERT_TRUE(result["isSigned"].toBool()); - LOGOS_ASSERT_TRUE(result["signatureValid"].toBool()); - LOGOS_ASSERT_TRUE(result["packageValid"].toBool()); - LOGOS_ASSERT_EQ(result["signerName"].toString(), QString("Test Signer")); - LOGOS_ASSERT_EQ(result["signerUrl"].toString(), QString("https://example.com")); + LOGOS_ASSERT_TRUE(result["isSigned"].get()); + LOGOS_ASSERT_TRUE(result["signatureValid"].get()); + LOGOS_ASSERT_TRUE(result["packageValid"].get()); + LOGOS_ASSERT_EQ(result["signerName"].get(), std::string("Test Signer")); + LOGOS_ASSERT_EQ(result["signerUrl"].get(), std::string("https://example.com")); // DID should start with did:jwk: - LOGOS_ASSERT_TRUE(result["signerDid"].toString().startsWith("did:jwk:")); + LOGOS_ASSERT_TRUE(result["signerDid"].get().substr(0, 8) == "did:jwk:"); // Not in keyring, so not trusted - LOGOS_ASSERT_TRUE(result["trustedAs"].toString().isEmpty()); + LOGOS_ASSERT_TRUE(result["trustedAs"].get().empty()); } // ============================================================================= @@ -211,9 +198,7 @@ LOGOS_TEST(verify_signed_package) { // ============================================================================= LOGOS_TEST(verify_signed_trusted_package) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); @@ -223,27 +208,27 @@ LOGOS_TEST(verify_signed_trusted_package) { QDir().mkpath(keysDir); QDir().mkpath(keyringDir); - impl.setKeyringDirectory(keyringDir); + impl.setKeyringDirectory(keyringDir.toStdString()); - QString lgxPath = createUnsignedPackage(tmpDir.path(), "verify_trusted"); - LOGOS_ASSERT_FALSE(lgxPath.isEmpty()); + std::string lgxPath = createUnsignedPackage(tmpDir.path(), "verify_trusted"); + LOGOS_ASSERT_FALSE(lgxPath.empty()); - QString keyPath = generateKey(keysDir, "trustkey"); - LOGOS_ASSERT_FALSE(keyPath.isEmpty()); + std::string keyPath = generateKey(keysDir, "trustkey"); + LOGOS_ASSERT_FALSE(keyPath.empty()); LOGOS_ASSERT_TRUE(signPackage(lgxPath, keyPath)); // Add key to keyring - QString did = readDid(keysDir, "trustkey"); - LOGOS_ASSERT_FALSE(did.isEmpty()); + std::string did = readDid(keysDir, "trustkey"); + LOGOS_ASSERT_FALSE(did.empty()); - QVariantMap addResult = impl.addTrustedKey("my-publisher", did, "Publisher Name", "https://pub.com"); - LOGOS_ASSERT_TRUE(addResult["success"].toBool()); + LogosMap addResult = impl.addTrustedKey("my-publisher", did, "Publisher Name", "https://pub.com"); + LOGOS_ASSERT_TRUE(addResult["success"].get()); - QVariantMap result = impl.verifyPackage(lgxPath); + LogosMap result = impl.verifyPackage(lgxPath); - LOGOS_ASSERT_TRUE(result["isSigned"].toBool()); - LOGOS_ASSERT_TRUE(result["signatureValid"].toBool()); - LOGOS_ASSERT_EQ(result["trustedAs"].toString(), QString("my-publisher")); + LOGOS_ASSERT_TRUE(result["isSigned"].get()); + LOGOS_ASSERT_TRUE(result["signatureValid"].get()); + LOGOS_ASSERT_EQ(result["trustedAs"].get(), std::string("my-publisher")); } // ============================================================================= @@ -251,41 +236,37 @@ LOGOS_TEST(verify_signed_trusted_package) { // ============================================================================= LOGOS_TEST(install_unsigned_with_policy_none_succeeds) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); impl.setSignaturePolicy("none"); - impl.setUserModulesDirectory(tmpDir.path() + "/modules"); - impl.setUserUiPluginsDirectory(tmpDir.path() + "/ui"); + impl.setUserModulesDirectory((tmpDir.path() + "/modules").toStdString()); + impl.setUserUiPluginsDirectory((tmpDir.path() + "/ui").toStdString()); - QString lgxPath = createUnsignedPackage(tmpDir.path(), "install_none"); - LOGOS_ASSERT_FALSE(lgxPath.isEmpty()); + std::string lgxPath = createUnsignedPackage(tmpDir.path(), "install_none"); + LOGOS_ASSERT_FALSE(lgxPath.empty()); - QVariantMap result = impl.installPlugin(lgxPath, false); + LogosMap result = impl.installPlugin(lgxPath, false); LOGOS_ASSERT_FALSE(result.contains("error")); } LOGOS_TEST(install_unsigned_with_policy_require_rejected) { - auto t = LogosTestContext("package_manager"); PackageManagerImpl impl; - t.init(&impl); QTemporaryDir tmpDir; LOGOS_ASSERT_TRUE(tmpDir.isValid()); impl.setSignaturePolicy("require"); - impl.setKeyringDirectory(tmpDir.path() + "/keyring"); - impl.setUserModulesDirectory(tmpDir.path() + "/modules"); - impl.setUserUiPluginsDirectory(tmpDir.path() + "/ui"); + impl.setKeyringDirectory((tmpDir.path() + "/keyring").toStdString()); + impl.setUserModulesDirectory((tmpDir.path() + "/modules").toStdString()); + impl.setUserUiPluginsDirectory((tmpDir.path() + "/ui").toStdString()); - QString lgxPath = createUnsignedPackage(tmpDir.path(), "install_req"); - LOGOS_ASSERT_FALSE(lgxPath.isEmpty()); + std::string lgxPath = createUnsignedPackage(tmpDir.path(), "install_req"); + LOGOS_ASSERT_FALSE(lgxPath.empty()); - QVariantMap result = impl.installPlugin(lgxPath, false); + LogosMap result = impl.installPlugin(lgxPath, false); LOGOS_ASSERT_TRUE(result.contains("error")); - LOGOS_ASSERT_TRUE(result["error"].toString().contains("unsigned")); + LOGOS_ASSERT_TRUE(result["error"].get().find("unsigned") != std::string::npos); }