folkslinux
/
dnf5
mirror of https://github.com/rpm-software-management/dnf5.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Merge 52feab7199 into 728a093201

This commit is contained in:
amatej 2025-07-10 13:29:26 -04:00 committed by GitHub
parent 728a093201 52feab7199
commit 5577be647a
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
35 changed files with 483 additions and 434 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
VERSION.cmake
View File

@ -1,6 +1,6 @@
set(DEFAULT_PROJECT_VERSION_PRIME 5)
set(DEFAULT_PROJECT_VERSION_MAJOR 2)
set(DEFAULT_PROJECT_VERSION_MINOR 14)
set(DEFAULT_PROJECT_VERSION_MAJOR 3)
set(DEFAULT_PROJECT_VERSION_MINOR 0)
set(DEFAULT_PROJECT_VERSION_MICRO 0)
if(DEFINED PROJECT_VERSION_PRIME)

18
bindings/libdnf5/comps.i
View File

@ -41,18 +41,20 @@
%include "libdnf5/comps/group/package.hpp"
%include "libdnf5/comps/group/group.hpp"
%template(VectorPackage) std::vector<libdnf5::comps::Package>;
%template(SetConstIteratorGroup) libdnf5::SetConstIterator<libdnf5::comps::Group>;
%template(SetGroup) libdnf5::Set<libdnf5::comps::Group>;
%template(SackQueryGroup) libdnf5::sack::Query<libdnf5::comps::Group>;
%template(GroupWeakPtr) libdnf5::WeakPtr<libdnf5::comps::Group, false>;
%template(SetConstIteratorGroupWeakPtr) libdnf5::SetConstIterator<libdnf5::comps::GroupWeakPtr>;
%template(SetGroupWeakPtr) libdnf5::Set<libdnf5::comps::GroupWeakPtr>;
%template(SackQueryGroupWeakPtr) libdnf5::sack::Query<libdnf5::comps::GroupWeakPtr>;
%include "libdnf5/comps/group/query.hpp"
add_iterator(SetGroup)
add_iterator(SetGroupWeakPtr)
%include "libdnf5/comps/environment/environment.hpp"
%template(SetConstIteratorEnvironment) libdnf5::SetConstIterator<libdnf5::comps::Environment>;
%template(SetEnvironment) libdnf5::Set<libdnf5::comps::Environment>;
%template(SackQueryEnvironment) libdnf5::sack::Query<libdnf5::comps::Environment>;
%template(EnvironmentWeakPtr) libdnf5::WeakPtr<libdnf5::comps::Environment, false>;
%template(SetConstIteratorEnvironmentWeakPtr) libdnf5::SetConstIterator<libdnf5::comps::EnvironmentWeakPtr>;
%template(SetEnvironmentWeakPtr) libdnf5::Set<libdnf5::comps::EnvironmentWeakPtr>;
%template(SackQueryEnvironmentWeakPtr) libdnf5::sack::Query<libdnf5::comps::EnvironmentWeakPtr>;
%include "libdnf5/comps/environment/query.hpp"
add_iterator(SetEnvironment)
add_iterator(SetEnvironmentWeakPtr)
%include "libdnf5/comps/comps_sack.hpp"
%template(CompsSackWeakPtr) libdnf5::WeakPtr<libdnf5::comps::CompsSack, false>;

8
dnf5.spec
View File

@ -1,6 +1,6 @@
%global project_version_prime 5
%global project_version_major 2
%global project_version_minor 14
%global project_version_major 3
%global project_version_minor 0
%global project_version_micro 0
%bcond dnf5_obsoletes_dnf %[0%{?fedora} > 40 || 0%{?rhel} > 10]
@ -404,7 +404,7 @@ Package management library.
%dir %{_datadir}/dnf5/repos.d
%dir %{_datadir}/dnf5/vars.d
%dir %{_libdir}/libdnf5
%{_libdir}/libdnf5.so.2*
%{_libdir}/libdnf5.so.3*
%dir %{_prefix}/lib/sysimage/libdnf5
%attr(0755, root, root) %ghost %dir %{_prefix}/lib/sysimage/libdnf5/comps_groups
%verify(not md5 size mtime) %attr(0644, root, root) %ghost %{_prefix}/lib/sysimage/libdnf5/environments.toml
@ -434,7 +434,7 @@ Requires: libdnf5%{?_isa} = %{version}-%{release}
Library for working with a terminal in a command-line package manager.
%files -n libdnf5-cli -f libdnf5-cli.lang
%{_libdir}/libdnf5-cli.so.2*
%{_libdir}/libdnf5-cli.so.3*
%license COPYING.md
%license lgpl-2.1.txt
%endif

6
dnf5/commands/environment/environment_info.cpp
View File

@ -69,14 +69,14 @@ void EnvironmentInfoCommand::run() {
query.filter_installed(false);
}
std::vector<libdnf5::comps::Environment> environments(query.list().begin(), query.list().end());
std::vector<libdnf5::comps::EnvironmentWeakPtr> environments(query.list().begin(), query.list().end());
std::sort(
environments.begin(),
environments.end(),
libdnf5::cli::output::comps_display_order_cmp<libdnf5::comps::Environment>);
libdnf5::cli::output::comps_display_order_cmp<libdnf5::comps::EnvironmentWeakPtr>);
for (auto environment : environments) {
libdnf5::cli::output::EnvironmentAdapter cli_env(environment);
libdnf5::cli::output::EnvironmentAdapter cli_env(*environment);
libdnf5::cli::output::print_environmentinfo_table(cli_env);
std::cout << '\n';
}

6
dnf5/commands/environment/environment_list.cpp
View File

@ -67,15 +67,15 @@ void EnvironmentListCommand::run() {
query.filter_installed(false);
}
std::vector<libdnf5::comps::Environment> environments(query.list().begin(), query.list().end());
std::vector<libdnf5::comps::EnvironmentWeakPtr> environments(query.list().begin(), query.list().end());
std::sort(
environments.begin(),
environments.end(),
libdnf5::cli::output::comps_display_order_cmp<libdnf5::comps::Environment>);
libdnf5::cli::output::comps_display_order_cmp<libdnf5::comps::EnvironmentWeakPtr>);
std::vector<std::unique_ptr<libdnf5::cli::output::IEnvironment>> cli_envs;
for (auto & env : environments) {
cli_envs.emplace_back(new libdnf5::cli::output::EnvironmentAdapter(env));
cli_envs.emplace_back(new libdnf5::cli::output::EnvironmentAdapter(*env));
}
libdnf5::cli::output::print_environmentlist_table(cli_envs);
}

7
dnf5/commands/group/group_info.cpp
View File

@ -29,11 +29,12 @@ namespace dnf5 {
using namespace libdnf5::cli;
void GroupInfoCommand::print(const libdnf5::comps::GroupQuery & query) {
std::vector<libdnf5::comps::Group> groups(query.list().begin(), query.list().end());
std::sort(groups.begin(), groups.end(), libdnf5::cli::output::comps_display_order_cmp<libdnf5::comps::Group>);
std::vector<libdnf5::comps::GroupWeakPtr> groups(query.list().begin(), query.list().end());
std::sort(
groups.begin(), groups.end(), libdnf5::cli::output::comps_display_order_cmp<libdnf5::comps::GroupWeakPtr>);
for (auto group : groups) {
libdnf5::cli::output::GroupAdapter cli_group(group);
libdnf5::cli::output::GroupAdapter cli_group(*group);
libdnf5::cli::output::print_groupinfo_table(cli_group);
std::cout << '\n';
}

9
dnf5/commands/group/group_list.cpp
View File

@ -76,7 +76,7 @@ void GroupListCommand::run() {
query_installed.filter_installed(true);
std::vector<std::string> installed_ids;
for (const auto & grp : query_installed) {
installed_ids.emplace_back(grp.get_groupid());
installed_ids.emplace_back(grp->get_groupid());
}
libdnf5::comps::GroupQuery query_available(query);
query_available.filter_installed(false);
@ -91,13 +91,14 @@ void GroupListCommand::run() {
}
void GroupListCommand::print(const libdnf5::comps::GroupQuery & query) {
std::vector<libdnf5::comps::Group> groups(query.list().begin(), query.list().end());
std::sort(groups.begin(), groups.end(), libdnf5::cli::output::comps_display_order_cmp<libdnf5::comps::Group>);
std::vector<libdnf5::comps::GroupWeakPtr> groups(query.list().begin(), query.list().end());
std::sort(
groups.begin(), groups.end(), libdnf5::cli::output::comps_display_order_cmp<libdnf5::comps::GroupWeakPtr>);
std::vector<std::unique_ptr<libdnf5::cli::output::IGroup>> items;
items.reserve(groups.size());
for (auto & obj : groups) {
items.emplace_back(new libdnf5::cli::output::GroupAdapter(obj));
items.emplace_back(new libdnf5::cli::output::GroupAdapter(*obj));
}
libdnf5::cli::output::print_grouplist_table(items);
}

4
dnf5/commands/system-upgrade/system-upgrade.cpp
View File

@ -123,13 +123,13 @@ void SystemUpgradeDownloadCommand::run() {
libdnf5::comps::GroupQuery q_groups(ctx.get_base());
q_groups.filter_installed(true);
for (const auto & grp : q_groups) {
goal->add_group_upgrade(grp.get_groupid());
goal->add_group_upgrade(grp->get_groupid());
}
libdnf5::comps::EnvironmentQuery q_environments(ctx.get_base());
q_environments.filter_installed(true);
for (const auto & env : q_environments) {
goal->add_group_upgrade(env.get_environmentid());
goal->add_group_upgrade(env->get_environmentid());
}
ctx.set_should_store_offline(true);

21
dnf5daemon-client/commands/group/group_list.cpp
View File

@ -109,24 +109,21 @@ void GroupListCommand::run() {
.withArguments(options)
.storeResultsTo(raw_groups);
std::vector<DbusGroupWrapper> groups{};
for (auto & group : raw_groups) {
groups.push_back(DbusGroupWrapper(group));
std::vector<std::unique_ptr<libdnf5::cli::output::IGroup>> cli_groups;
for (auto & g : raw_groups) {
cli_groups.emplace_back(new libdnf5::cli::output::GroupAdapter(DbusGroupWrapper(g)));
}
std::sort(groups.begin(), groups.end(), libdnf5::cli::output::comps_display_order_cmp<DbusGroupWrapper>);
std::sort(
cli_groups.begin(),
cli_groups.end(),
libdnf5::cli::output::comps_display_order_cmp<std::unique_ptr<libdnf5::cli::output::IGroup>>);
if (command == "info") {
for (auto & group : groups) {
libdnf5::cli::output::GroupAdapter cli_group(group);
libdnf5::cli::output::print_groupinfo_table(cli_group);
for (auto & cli_group : cli_groups) {
libdnf5::cli::output::print_groupinfo_table(*cli_group);
std::cout << '\n';
}
} else {
std::vector<std::unique_ptr<libdnf5::cli::output::IGroup>> cli_groups;
for (auto & sorted_group : groups) {
cli_groups.emplace_back(new libdnf5::cli::output::GroupAdapter(DbusGroupWrapper(sorted_group)));
}
libdnf5::cli::output::print_grouplist_table(cli_groups);
}
}

4
dnf5daemon-server/services/comps/group.cpp
View File

@ -107,7 +107,7 @@ sdbus::MethodReply Group::list(sdbus::MethodCall & call) {
query_installed.filter_installed(true);
std::vector<std::string> installed_ids;
for (const auto & grp : query_installed) {
installed_ids.emplace_back(grp.get_groupid());
installed_ids.emplace_back(grp->get_groupid());
}
libdnf5::comps::GroupQuery query_available(query);
query_available.filter_installed(false);
@ -127,7 +127,7 @@ sdbus::MethodReply Group::list(sdbus::MethodCall & call) {
std::vector<std::string> attributes =
dnfdaemon::key_value_map_get<std::vector<std::string>>(options, "attributes", std::vector<std::string>{});
for (auto grp : query.list()) {
out_groups.push_back(group_to_map(grp, attributes));
out_groups.push_back(group_to_map(*grp, attributes));
}
auto reply = call.createReply();

4
dnf5daemon-server/services/rpm/rpm.cpp
View File

@ -858,13 +858,13 @@ sdbus::MethodReply Rpm::system_upgrade(sdbus::MethodCall & call) {
libdnf5::comps::GroupQuery q_groups(*base);
q_groups.filter_installed(true);
for (const auto & grp : q_groups) {
goal.add_group_upgrade(grp.get_groupid());
goal.add_group_upgrade(grp->get_groupid());
}
libdnf5::comps::EnvironmentQuery q_environments(*base);
q_environments.filter_installed(true);
for (const auto & env : q_environments) {
goal.add_group_upgrade(env.get_environmentid());
goal.add_group_upgrade(env->get_environmentid());
}
auto reply = call.createReply();

34
doc/api/changes_dnf5.3.rst Normal file
View File

@ -0,0 +1,34 @@
###############################################
Modifications to the public API in dnf 5.3.0.0
###############################################
This page lists the differences in the public API of `DNF5 5.3 <https://github.com/rpm-software-management/dnf5/releases/tag/5.3.0.0>`_ compared to the previous major version, DNF5 5.2.
`Here <https://raw.githubusercontent.com/rpm-software-management/dnf5/main/doc/api/changes_dnf5.3.diff>`_'s the full diff showing the changes in the libdnf5 API.
Group and Environment queries return weak pointers
==================================================
Before: Group and Environment queries stored objects directly, this meant that
when a query was destroyed any references to its objects became invalid.
Now: The Groups and Environments are created only once and stored in libdnf5::comps::CompsSack in libdnf5::Base.
Queries contain only weak pointers to objects in CompsSack. When a query is destroyed any
pointers to Groups or Environments obtained from it remain valid (as long as the Base lives).
This means that the queries return pointers instead of references.
.. code-block:: cpp
comps::GroupQuery group_query(base);
for (const auto & group : group_query) {
std::cout << "id: " << group.get_groupid();
}
has to turn into:
.. code-block:: cpp
comps::GroupQuery group_query(base);
for (const auto & group : group_query) {
std::cout << "id: " << group->get_groupid();
}

2
include/libdnf5-cli/output/adapters/comps_tmpl.hpp
View File

@ -124,7 +124,7 @@ private:
template <class T>
bool comps_display_order_cmp(T & a, T & b) {
return a.get_order_int() < b.get_order_int();
return a->get_order_int() < b->get_order_int();
}
} // namespace libdnf5::cli::output

4
include/libdnf5/comps/environment/environment.hpp
View File

@ -45,6 +45,9 @@ public:
};
class Environment;
using EnvironmentWeakPtr = WeakPtr<Environment, false>;
// @replaces dnf:dnf/comps.py:class:Environment
class LIBDNF_API Environment {
public:
@ -147,6 +150,7 @@ protected:
private:
friend class EnvironmentQuery;
friend class CompsSack;
LIBDNF_LOCAL void add_environment_id(const EnvironmentId & environment_id);

2
include/libdnf5/comps/environment/query.hpp
View File

@ -33,7 +33,7 @@ along with libdnf. If not, see <https://www.gnu.org/licenses/>.
namespace libdnf5::comps {
class LIBDNF_API EnvironmentQuery : public libdnf5::sack::Query<Environment> {
class LIBDNF_API EnvironmentQuery : public libdnf5::sack::Query<EnvironmentWeakPtr> {
public:
using ExcludeFlags = libdnf5::sack::ExcludeFlags;

3
include/libdnf5/comps/group/group.hpp
View File

@ -45,6 +45,8 @@ public:
int id{0};
};
class Group;
using GroupWeakPtr = WeakPtr<Group, false>;
// @replaces dnf:dnf/comps.py:class:Group
class LIBDNF_API Group {
@ -164,6 +166,7 @@ protected:
private:
friend class GroupQuery;
friend class CompsSack;
LIBDNF_LOCAL void add_group_id(const GroupId & group_id);

2
include/libdnf5/comps/group/query.hpp
View File

@ -33,7 +33,7 @@ along with libdnf. If not, see <https://www.gnu.org/licenses/>.
namespace libdnf5::comps {
class LIBDNF_API GroupQuery : public libdnf5::sack::Query<Group> {
class LIBDNF_API GroupQuery : public libdnf5::sack::Query<GroupWeakPtr> {
public:
using ExcludeFlags = libdnf5::sack::ExcludeFlags;

2
libdnf5-cli/CMakeLists.txt
View File

@ -29,7 +29,7 @@ include_directories(.)
# build libdnf5-cli.so
add_library(libdnf5-cli SHARED ${LIBDNF5_CLI_SOURCES})
set(DNF_CLI_SO_VERSION 2)
set(DNF_CLI_SO_VERSION 3)
set_target_properties(libdnf5-cli PROPERTIES OUTPUT_NAME "dnf5-cli")
set_target_properties(libdnf5-cli PROPERTIES SOVERSION ${DNF_CLI_SO_VERSION})
set_target_properties(libdnf5-cli PROPERTIES C_VISIBILITY_PRESET hidden CXX_VISIBILITY_PRESET hidden)

2
libdnf5/CMakeLists.txt
View File

@ -42,7 +42,7 @@ target_link_libraries(libdnf5_iface INTERFACE libdnf5_obj $<TARGET_OBJECTS:libdn
# build libdnf5.so
add_library(libdnf5 SHARED $<TARGET_OBJECTS:libdnf5_obj>)
set(DNF_SO_VERSION 2)
set(DNF_SO_VERSION 3)
set_target_properties(libdnf5 PROPERTIES OUTPUT_NAME "dnf5")
set_target_properties(libdnf5 PROPERTIES SOVERSION ${DNF_SO_VERSION})
# required to have dlopen symbol

54
libdnf5/base/goal.cpp
View File

@ -1244,7 +1244,7 @@ GoalProblem Goal::Impl::resolve_group_specs(std::vector<GroupSpec> & specs, base
// We cannot simply compare the groups because they can have different libsolv ids,
// we have to compare them by groupid.
auto group_q_copy = group_q;
group_q_copy.filter_groupid(group.get_groupid());
group_q_copy.filter_groupid(group->get_groupid());
if (!group_q_copy.empty()) {
// If we have multiple different actions per group it always ends up as upgrade.
// This is because there are only 3 actions: INSTALL (together with INSTALL_BY_COMPS),
@ -2515,13 +2515,13 @@ void Goal::Impl::add_group_install_to_goal(
auto & cfg_main = base->get_config();
auto allowed_package_types = settings.resolve_group_package_types(cfg_main);
for (auto group : group_query) {
rpm_goal.add_group(group, transaction::TransactionItemAction::INSTALL, reason, allowed_package_types);
rpm_goal.add_group(*group, transaction::TransactionItemAction::INSTALL, reason, allowed_package_types);
if (settings.get_group_no_packages()) {
continue;
}
std::vector<libdnf5::comps::Package> packages;
// TODO(mblaha): filter packages by p.arch attribute when supported by comps
for (const auto & p : group.get_packages()) {
for (const auto & p : group->get_packages()) {
if (any(allowed_package_types & p.get_type())) {
packages.emplace_back(std::move(p));
}
@ -2543,7 +2543,7 @@ void Goal::Impl::add_group_remove_to_goal(
std::set<std::string> removed_groups_ids;
for (auto & [spec, reason, group_query, settings] : groups_to_remove) {
for (const auto & group : group_query) {
removed_groups_ids.emplace(group.get_groupid());
removed_groups_ids.emplace(group->get_groupid());
}
}
rpm::PackageQuery query_installed(base);
@ -2553,13 +2553,13 @@ void Goal::Impl::add_group_remove_to_goal(
rpm::PackageSet remove_candidates(base);
for (auto & [spec, reason, group_query, settings] : groups_to_remove) {
for (const auto & group : group_query) {
rpm_goal.add_group(group, transaction::TransactionItemAction::REMOVE, reason, {});
rpm_goal.add_group(*group, transaction::TransactionItemAction::REMOVE, reason, {});
if (settings.get_group_no_packages()) {
continue;
}
// get all packages installed by the group
rpm::PackageQuery group_packages(query_installed);
group_packages.filter_name(system_state.get_group_state(group.get_groupid()).packages);
group_packages.filter_name(system_state.get_group_state(group->get_groupid()).packages);
// Remove packages installed by the group.
// First collect packages that are not part of any other
// installed group and are not user-installed.
@ -2601,7 +2601,7 @@ void Goal::Impl::add_group_upgrade_to_goal(
query_installed.filter_installed();
for (auto installed_group : group_query) {
auto group_id = installed_group.get_groupid();
auto group_id = installed_group->get_groupid();
// find available group of the same id
comps::GroupQuery available_group_query(available_groups);
available_group_query.filter_groupid(group_id);
@ -2622,9 +2622,9 @@ void Goal::Impl::add_group_upgrade_to_goal(
// upgrade the group itself
rpm_goal.add_group(
available_group,
*available_group,
transaction::TransactionItemAction::UPGRADE,
installed_group.get_reason(),
installed_group->get_reason(),
state_group.package_types);
if (settings.get_group_no_packages()) {
@ -2634,17 +2634,17 @@ void Goal::Impl::add_group_upgrade_to_goal(
// set of package names that are part of the installed version of the group
std::set<std::string> old_set{};
for (const auto & pkg : installed_group.get_packages()) {
for (const auto & pkg : installed_group->get_packages()) {
old_set.emplace(pkg.get_name());
}
// set of package names that are part of the available version of the group
std::set<std::string> new_set{};
for (const auto & pkg : available_group.get_packages()) {
for (const auto & pkg : available_group->get_packages()) {
new_set.emplace(pkg.get_name());
}
// install packages newly added to the group
for (const auto & pkg : available_group.get_packages_of_type(state_group.package_types)) {
for (const auto & pkg : available_group->get_packages_of_type(state_group.package_types)) {
if (!old_set.contains(pkg.get_name())) {
install_group_package(transaction, pkg);
}
@ -2673,16 +2673,16 @@ void Goal::Impl::add_environment_install_to_goal(
group_settings.set_group_search_groups(true);
std::vector<GroupSpec> env_group_specs;
for (auto environment : environment_query) {
rpm_goal.add_environment(environment, transaction::TransactionItemAction::INSTALL, with_optional);
rpm_goal.add_environment(*environment, transaction::TransactionItemAction::INSTALL, with_optional);
if (settings.get_environment_no_groups()) {
continue;
}
for (const auto & grp_id : environment.get_groups()) {
for (const auto & grp_id : environment->get_groups()) {
env_group_specs.emplace_back(
GoalAction::INSTALL_BY_COMPS, transaction::TransactionItemReason::DEPENDENCY, grp_id, group_settings);
}
if (with_optional) {
for (const auto & grp_id : environment.get_optional_groups()) {
for (const auto & grp_id : environment->get_optional_groups()) {
env_group_specs.emplace_back(
GoalAction::INSTALL_BY_COMPS,
transaction::TransactionItemReason::DEPENDENCY,
@ -2705,7 +2705,7 @@ void Goal::Impl::add_environment_remove_to_goal(
std::set<std::string> removed_environments_ids;
for (auto & [spec, environment_query, settings] : environments_to_remove) {
for (const auto & environment : environment_query) {
removed_environments_ids.emplace(environment.get_environmentid());
removed_environments_ids.emplace(environment->get_environmentid());
}
}
comps::GroupQuery query_installed(base);
@ -2718,19 +2718,19 @@ void Goal::Impl::add_environment_remove_to_goal(
group_settings.set_group_search_groups(true);
for (auto & [spec, environment_query, settings] : environments_to_remove) {
for (const auto & environment : environment_query) {
rpm_goal.add_environment(environment, transaction::TransactionItemAction::REMOVE, {});
rpm_goal.add_environment(*environment, transaction::TransactionItemAction::REMOVE, {});
if (settings.get_environment_no_groups()) {
continue;
}
// get all groups installed by the environment
comps::GroupQuery environment_groups(query_installed);
environment_groups.filter_groupid(
system_state.get_environment_state(environment.get_environmentid()).groups);
system_state.get_environment_state(environment->get_environmentid()).groups);
// Remove groups installed by the environment in case they are installed
// as dependencies and are not part of another installed environment.
for (const auto & grp : environment_groups) {
// is the group part of another environment which is not being removed?
auto grp_environments = system_state.get_group_environments(grp.get_groupid());
auto grp_environments = system_state.get_group_environments(grp->get_groupid());
// remove from the list all environments being removed in this transaction
for (const auto & id : removed_environments_ids) {
grp_environments.erase(id);
@ -2740,14 +2740,14 @@ void Goal::Impl::add_environment_remove_to_goal(
}
// was the group user-installed?
if (grp.get_reason() > transaction::TransactionItemReason::GROUP) {
if (grp->get_reason() > transaction::TransactionItemReason::GROUP) {
continue;
}
remove_group_specs.emplace_back(
GoalAction::REMOVE,
transaction::TransactionItemReason::DEPENDENCY,
grp.get_groupid(),
grp->get_groupid(),
group_settings);
}
}
@ -2768,7 +2768,7 @@ void Goal::Impl::add_environment_upgrade_to_goal(
group_settings.set_group_search_groups(true);
for (auto installed_environment : environment_query) {
auto environment_id = installed_environment.get_environmentid();
auto environment_id = installed_environment->get_environmentid();
// find available environment of the same id
comps::EnvironmentQuery available_environment_query(available_environments);
available_environment_query.filter_environmentid(environment_id);
@ -2787,17 +2787,17 @@ void Goal::Impl::add_environment_upgrade_to_goal(
auto available_environment = available_environment_query.get();
// upgrade the environment itself
rpm_goal.add_environment(available_environment, transaction::TransactionItemAction::UPGRADE, {});
rpm_goal.add_environment(*available_environment, transaction::TransactionItemAction::UPGRADE, {});
if (settings.get_environment_no_groups()) {
continue;
}
// group names that are part of the installed version of the environment
auto old_groups = installed_environment.get_groups();
auto old_groups = installed_environment->get_groups();
// group names that are part of the new version of the environment
auto available_groups = available_environment.get_groups();
auto available_groups = available_environment->get_groups();
for (const auto & grp : available_groups) {
if (std::find(old_groups.begin(), old_groups.end(), grp) != old_groups.end()) {
@ -2818,9 +2818,9 @@ void Goal::Impl::add_environment_upgrade_to_goal(
}
// upgrade also installed optional groups
auto old_optionals = installed_environment.get_optional_groups();
auto old_optionals = installed_environment->get_optional_groups();
old_groups.insert(old_groups.end(), old_optionals.begin(), old_optionals.end());
for (const auto & grp : available_environment.get_optional_groups()) {
for (const auto & grp : available_environment->get_optional_groups()) {
available_groups.emplace_back(grp);
if (std::find(old_groups.begin(), old_groups.end(), grp) != old_groups.end()) {
try {

2
libdnf5/base/transaction.cpp
View File

@ -1037,7 +1037,7 @@ Transaction::TransactionRunResult Transaction::Impl::_run(
installed_query.filter_installed(true);
std::set<std::string> installed_group_ids{};
for (const auto & grp : installed_query) {
installed_group_ids.emplace(grp.get_groupid());
installed_group_ids.emplace(grp->get_groupid());
}
for (const auto & tsgrp : groups) {
if (transaction_item_action_is_inbound(tsgrp.get_action())) {

109
libdnf5/comps/comps_sack.cpp
View File

@ -20,6 +20,7 @@ along with libdnf. If not, see <https://www.gnu.org/licenses/>.
#include "libdnf5/comps/comps_sack.hpp"
#include "comps_sack_impl.hpp"
#include "solv/pool.hpp"
#include "libdnf5/comps/group/query.hpp"
@ -40,14 +41,14 @@ void CompsSack::Impl::load_config_excludes() {
EnvironmentQuery query(base, EnvironmentQuery::ExcludeFlags::IGNORE_EXCLUDES);
query.filter_environmentid(name, libdnf5::sack::QueryCmp::GLOB);
for (const auto & environment : query.list()) {
config_environment_excludes.insert(environment.get_environmentid());
config_environment_excludes.insert(environment->get_environmentid());
}
}
for (const auto & name : main_config.get_excludegroups_option().get_value()) {
GroupQuery query(base, GroupQuery::ExcludeFlags::IGNORE_EXCLUDES);
query.filter_groupid(name, libdnf5::sack::QueryCmp::GLOB);
for (const auto & group : query.list()) {
config_group_excludes.insert(group.get_groupid());
config_group_excludes.insert(group->get_groupid());
}
}
}
@ -69,14 +70,14 @@ void CompsSack::Impl::add_user_environment_excludes(const std::set<std::string>
EnvironmentQuery query(base, EnvironmentQuery::ExcludeFlags::IGNORE_EXCLUDES);
query.filter_environmentid(exclude, libdnf5::sack::QueryCmp::GLOB);
for (const auto & environment : query.list()) {
user_environment_excludes.insert(environment.get_environmentid());
user_environment_excludes.insert(environment->get_environmentid());
}
}
}
void CompsSack::Impl::add_user_environment_excludes(const EnvironmentQuery & excludes) {
for (const auto & environment : excludes) {
user_environment_excludes.insert(environment.get_environmentid());
user_environment_excludes.insert(environment->get_environmentid());
}
}
@ -85,14 +86,14 @@ void CompsSack::Impl::remove_user_environment_excludes(const std::set<std::strin
EnvironmentQuery query(base, EnvironmentQuery::ExcludeFlags::IGNORE_EXCLUDES);
query.filter_environmentid(exclude, libdnf5::sack::QueryCmp::GLOB);
for (const auto & environment : query.list()) {
user_environment_excludes.erase(environment.get_environmentid());
user_environment_excludes.erase(environment->get_environmentid());
}
}
}
void CompsSack::Impl::remove_user_environment_excludes(const EnvironmentQuery & excludes) {
for (const auto & environment : excludes) {
user_environment_excludes.erase(environment.get_environmentid());
user_environment_excludes.erase(environment->get_environmentid());
}
}
@ -102,7 +103,7 @@ void CompsSack::Impl::set_user_environment_excludes(const std::set<std::string>
EnvironmentQuery query(base, EnvironmentQuery::ExcludeFlags::IGNORE_EXCLUDES);
query.filter_environmentid(exclude, libdnf5::sack::QueryCmp::GLOB);
for (const auto & environment : query.list()) {
user_environment_excludes.insert(environment.get_environmentid());
user_environment_excludes.insert(environment->get_environmentid());
}
}
}
@ -110,7 +111,7 @@ void CompsSack::Impl::set_user_environment_excludes(const std::set<std::string>
void CompsSack::Impl::set_user_environment_excludes(const EnvironmentQuery & excludes) {
user_environment_excludes = std::set<std::string>();
for (const auto & environment : excludes) {
user_environment_excludes.insert(environment.get_environmentid());
user_environment_excludes.insert(environment->get_environmentid());
}
}
@ -127,14 +128,14 @@ void CompsSack::Impl::add_user_group_excludes(const std::set<std::string> & excl
GroupQuery query(base, GroupQuery::ExcludeFlags::IGNORE_EXCLUDES);
query.filter_groupid(exclude, libdnf5::sack::QueryCmp::GLOB);
for (const auto & group : query.list()) {
user_group_excludes.insert(group.get_groupid());
user_group_excludes.insert(group->get_groupid());
}
}
}
void CompsSack::Impl::add_user_group_excludes(const GroupQuery & excludes) {
for (const auto & group : excludes) {
user_group_excludes.insert(group.get_groupid());
user_group_excludes.insert(group->get_groupid());
}
}
@ -143,14 +144,14 @@ void CompsSack::Impl::remove_user_group_excludes(const std::set<std::string> & e
GroupQuery query(base, GroupQuery::ExcludeFlags::IGNORE_EXCLUDES);
query.filter_groupid(exclude, libdnf5::sack::QueryCmp::GLOB);
for (const auto & group : query.list()) {
user_group_excludes.erase(group.get_groupid());
user_group_excludes.erase(group->get_groupid());
}
}
}
void CompsSack::Impl::remove_user_group_excludes(const GroupQuery & excludes) {
for (const auto & group : excludes) {
user_group_excludes.erase(group.get_groupid());
user_group_excludes.erase(group->get_groupid());
}
}
@ -160,7 +161,7 @@ void CompsSack::Impl::set_user_group_excludes(const std::set<std::string> & excl
GroupQuery query(base, GroupQuery::ExcludeFlags::IGNORE_EXCLUDES);
query.filter_groupid(exclude, libdnf5::sack::QueryCmp::GLOB);
for (const auto & group : query.list()) {
user_group_excludes.insert(group.get_groupid());
user_group_excludes.insert(group->get_groupid());
}
}
}
@ -168,7 +169,7 @@ void CompsSack::Impl::set_user_group_excludes(const std::set<std::string> & excl
void CompsSack::Impl::set_user_group_excludes(const GroupQuery & excludes) {
user_group_excludes = std::set<std::string>();
for (const auto & group : excludes) {
user_group_excludes.insert(group.get_groupid());
user_group_excludes.insert(group->get_groupid());
}
}
@ -242,4 +243,84 @@ void CompsSack::clear_user_group_excludes() {
p_impl->clear_user_group_excludes();
}
void CompsSack::Impl::init_comps_data() {
libdnf5::solv::CompsPool & pool = get_comps_pool(base);
if (comps_pool_cached_solvables_size == pool.get_nsolvables()) {
return;
}
group_data.clear();
environment_data.clear();
// Map of available groups/envs:
// For each groupid/envid (SOLVABLE_NAME) have a vector of (repoid, solvable_id) pairs.
// Each pair consists of one solvable_id that represents one definition of the group/env
// and repoid of its originating repository.
std::map<std::string, std::vector<std::pair<std::string_view, Id>>> group_available_map;
std::map<std::string, std::vector<std::pair<std::string_view, Id>>> env_available_map;
Id solvable_id;
Solvable * solvable;
std::pair<std::string, std::string> solvable_name_pair;
std::string_view repoid;
// Loop over all solvables
FOR_POOL_SOLVABLES(solvable_id) {
solvable = pool.id2solvable(solvable_id);
// SOLVABLE_NAME is in a form "type:id"; include only solvables of type "group" or "environment"
solvable_name_pair = solv::CompsPool::split_solvable_name(pool.lookup_str(solvable_id, SOLVABLE_NAME));
repoid = solvable->repo->name;
// Add installed groups/envs directly, because there is only one solvable for each
if (repoid == "@System") {
if (solvable_name_pair.first == "group") {
std::unique_ptr<Group> group(new Group(base));
group->add_group_id(GroupId(solvable_id));
group_data.push_back(std::move(group));
} else if (solvable_name_pair.first == "environment") {
std::unique_ptr<Environment> environment(new Environment(base));
environment->add_environment_id(EnvironmentId(solvable_id));
environment_data.push_back(std::move(environment));
}
} else {
// Create map of available groups/envs:
// for each groupid (SOLVABLE_NAME), list all corresponding solvable_ids with repoids
if (solvable_name_pair.first == "group") {
group_available_map[solvable_name_pair.second].insert(
group_available_map[solvable_name_pair.second].end(), std::make_pair(repoid, solvable_id));
} else if (solvable_name_pair.first == "environment") {
env_available_map[solvable_name_pair.second].insert(
env_available_map[solvable_name_pair.second].end(), std::make_pair(repoid, solvable_id));
}
}
}
// Create groups based on the group_available_map
for (auto & item : group_available_map) {
std::unique_ptr<Group> group(new Group(base));
// Sort the vector of (repoid, solvable_id) pairs by repoid
std::sort(item.second.begin(), item.second.end(), std::greater<>());
// Create group_ids vector from the sorted solvable_ids
for (const auto & solvableid_repoid_pair : item.second) {
group->add_group_id(GroupId(solvableid_repoid_pair.second));
}
group_data.push_back(std::move(group));
}
// Create envs based on the env_available_map
for (auto & item : env_available_map) {
std::unique_ptr<Environment> environment(new Environment(base));
// Sort the vector of (repoid, solvable_id) pairs by repoid
std::sort(item.second.begin(), item.second.end(), std::greater<>());
// Create environment_ids vector from the sorted solvable_ids
for (const auto & solvableid_repoid_pair : item.second) {
environment->add_environment_id(EnvironmentId(solvableid_repoid_pair.second));
}
environment_data.push_back(std::move(environment));
}
comps_pool_cached_solvables_size = pool.get_nsolvables();
}
} // namespace libdnf5::comps

15
libdnf5/comps/comps_sack_impl.hpp
View File

@ -27,7 +27,6 @@ along with libdnf. If not, see <https://www.gnu.org/licenses/>.
namespace libdnf5::comps {
class CompsSack::Impl {
public:
explicit Impl(const BaseWeakPtr & base) : base(base) {}
@ -59,8 +58,13 @@ public:
void set_user_group_excludes(const GroupQuery & excludes);
void clear_user_group_excludes();
// Loads groups and environments into group_data and environment_data
void init_comps_data();
private:
friend comps::CompsSack;
friend comps::GroupQuery;
friend comps::EnvironmentQuery;
BaseWeakPtr base;
WeakPtrGuard<comps::CompsSack, false> sack_guard;
@ -69,6 +73,15 @@ private:
std::set<std::string> config_group_excludes; // groups explicitly excluded by config
std::set<std::string> user_environment_excludes; // environments explicitly excluded by API user
std::set<std::string> user_group_excludes; // groups explicitly excluded by API user
WeakPtrGuard<comps::Group, false> group_data_guard;
std::vector<std::unique_ptr<comps::Group>> group_data;
WeakPtrGuard<comps::Environment, false> environment_data_guard;
std::vector<std::unique_ptr<comps::Environment>> environment_data;
// Number of solvables in the comps pool when the
// group/environment_data vectors were initialized.
int comps_pool_cached_solvables_size{0};
};

74
libdnf5/comps/environment/query.cpp
View File

@ -19,6 +19,7 @@ along with libdnf. If not, see <https://www.gnu.org/licenses/>.
#include "libdnf5/comps/environment/query.hpp"
#include "../comps_sack_impl.hpp"
#include "solv/pool.hpp"
#include "libdnf5/base/base.hpp"
@ -47,9 +48,9 @@ private:
friend EnvironmentQuery;
struct F {
static std::string environmentid(const Environment & obj) { return obj.get_environmentid(); }
static std::string name(const Environment & obj) { return obj.get_name(); }
static bool is_installed(const Environment & obj) { return obj.get_installed(); }
static std::string environmentid(const EnvironmentWeakPtr & obj) { return obj->get_environmentid(); }
static std::string name(const EnvironmentWeakPtr & obj) { return obj->get_name(); }
static bool is_installed(const EnvironmentWeakPtr & obj) { return obj->get_installed(); }
};
libdnf5::BaseWeakPtr base;
@ -61,74 +62,21 @@ EnvironmentQuery::EnvironmentQuery(const BaseWeakPtr & base, ExcludeFlags flags,
return;
}
libdnf5::solv::CompsPool & pool = get_comps_pool(base);
auto sack = base->get_comps_sack();
// Map of available environments:
// For each environmentid (SOLVABLE_NAME) have a vector of (repoid, solvable_id) pairs.
// Each pair consists of one solvable_id that represents one definition of the environment
// and repoid of its originating repository.
std::map<std::string, std::vector<std::pair<std::string_view, Id>>> available_map;
Id solvable_id;
Solvable * solvable;
std::pair<std::string, std::string> solvable_name_pair;
std::string_view repoid;
std::set<std::string> config_excludes = sack->get_config_environment_excludes();
std::set<std::string> user_excludes = sack->get_user_environment_excludes();
// Loop over all solvables
FOR_POOL_SOLVABLES(solvable_id) {
solvable = pool.id2solvable(solvable_id);
// Do not include solvables from disabled repositories (unless ExcludeFlags::USE_DISABLED_REPOSITORIES).
// TODO(pkratoch): Test this works
if (solvable->repo->disabled &&
!static_cast<bool>(flags & libdnf5::sack::ExcludeFlags::USE_DISABLED_REPOSITORIES)) {
continue;
}
// SOLVABLE_NAME is in a form "type:id"; include only solvables of type "environment"
solvable_name_pair = solv::CompsPool::split_solvable_name(pool.lookup_str(solvable_id, SOLVABLE_NAME));
if (solvable_name_pair.first != "environment") {
continue;
}
sack->p_impl->init_comps_data();
for (auto & it : sack->p_impl->environment_data) {
// Check config excludes
if (!static_cast<bool>(flags & libdnf5::sack::ExcludeFlags::IGNORE_REGULAR_CONFIG_EXCLUDES) &&
config_excludes.contains(solvable_name_pair.second)) {
sack->p_impl->get_config_environment_excludes().contains(it->get_environmentid())) {
continue;
}
// Check user excludes
if (!static_cast<bool>(flags & libdnf5::sack::ExcludeFlags::IGNORE_REGULAR_USER_EXCLUDES) &&
user_excludes.contains(solvable_name_pair.second)) {
sack->p_impl->get_user_environment_excludes().contains(it->get_environmentid())) {
continue;
}
repoid = solvable->repo->name;
// Add installed environments directly, because there is only one solvable for each
if (repoid == "@System") {
Environment environment(base);
environment.add_environment_id(EnvironmentId(solvable_id));
add(environment);
} else {
// Create map of available environments:
// for each environmentid (SOLVABLE_NAME), list all corresponding solvable_ids with repoids
available_map[solvable_name_pair.second].insert(
available_map[solvable_name_pair.second].end(), std::make_pair(repoid, solvable_id));
}
}
// Create environments based on the available_map
for (auto & item : available_map) {
Environment environment(base);
// Sort the vector of (repoid, solvable_id) pairs by repoid
std::sort(item.second.begin(), item.second.end(), std::greater<>());
// Create environment_ids vector from the sorted solvable_ids
for (const auto & solvableid_repoid_pair : item.second) {
environment.add_environment_id(EnvironmentId(solvableid_repoid_pair.second));
}
add(environment);
add({it.get(), &sack->p_impl->environment_data_guard});
}
}
@ -143,12 +91,12 @@ EnvironmentQuery::EnvironmentQuery(Base & base, ExcludeFlags flags, bool empty)
EnvironmentQuery::~EnvironmentQuery() = default;
EnvironmentQuery::EnvironmentQuery(const EnvironmentQuery & src)
: libdnf5::sack::Query<Environment>(src),
: libdnf5::sack::Query<EnvironmentWeakPtr>(src),
p_impl(new Impl(*src.p_impl)) {}
EnvironmentQuery::EnvironmentQuery(EnvironmentQuery && src) noexcept = default;
EnvironmentQuery & EnvironmentQuery::operator=(const EnvironmentQuery & src) {
libdnf5::sack::Query<Environment>::operator=(src);
libdnf5::sack::Query<EnvironmentWeakPtr>::operator=(src);
if (this != &src) {
if (p_impl) {
*p_impl = *src.p_impl;

84
libdnf5/comps/group/query.cpp
View File

@ -19,6 +19,7 @@ along with libdnf. If not, see <https://www.gnu.org/licenses/>.
#include "libdnf5/comps/group/query.hpp"
#include "../comps_sack_impl.hpp"
#include "solv/pool.hpp"
#include "libdnf5/base/base.hpp"
@ -47,11 +48,11 @@ private:
friend GroupQuery;
struct F {
static std::string groupid(const Group & obj) { return obj.get_groupid(); }
static std::string name(const Group & obj) { return obj.get_name(); }
static bool is_uservisible(const Group & obj) { return obj.get_uservisible(); }
static bool is_default(const Group & obj) { return obj.get_default(); }
static bool is_installed(const Group & obj) { return obj.get_installed(); }
static std::string groupid(const GroupWeakPtr & obj) { return obj->get_groupid(); }
static std::string name(const GroupWeakPtr & obj) { return obj->get_name(); }
static bool is_uservisible(const GroupWeakPtr & obj) { return obj->get_uservisible(); }
static bool is_default(const GroupWeakPtr & obj) { return obj->get_default(); }
static bool is_installed(const GroupWeakPtr & obj) { return obj->get_installed(); }
};
libdnf5::BaseWeakPtr base;
@ -63,74 +64,21 @@ GroupQuery::GroupQuery(const BaseWeakPtr & base, ExcludeFlags flags, bool empty)
return;
}
libdnf5::solv::CompsPool & pool = get_comps_pool(base);
auto sack = base->get_comps_sack();
// Map of available groups:
// For each groupid (SOLVABLE_NAME) have a vector of (repoid, solvable_id) pairs.
// Each pair consists of one solvable_id that represents one definition of the group
// and repoid of its originating repository.
std::map<std::string, std::vector<std::pair<std::string_view, Id>>> available_map;
Id solvable_id;
Solvable * solvable;
std::pair<std::string, std::string> solvable_name_pair;
std::string_view repoid;
std::set<std::string> config_excludes = sack->get_config_group_excludes();
std::set<std::string> user_excludes = sack->get_user_group_excludes();
// Loop over all solvables
FOR_POOL_SOLVABLES(solvable_id) {
solvable = pool.id2solvable(solvable_id);
// Do not include solvables from disabled repositories (unless ExcludeFlags::USE_DISABLED_REPOSITORIES).
// TODO(pkratoch): Test this works
if (solvable->repo->disabled &&
!static_cast<bool>(flags & libdnf5::sack::ExcludeFlags::USE_DISABLED_REPOSITORIES)) {
continue;
}
// SOLVABLE_NAME is in a form "type:id"; include only solvables of type "group"
solvable_name_pair = solv::CompsPool::split_solvable_name(pool.lookup_str(solvable_id, SOLVABLE_NAME));
if (solvable_name_pair.first != "group") {
continue;
}
sack->p_impl->init_comps_data();
for (auto & it : sack->p_impl->group_data) {
// Check config excludes
if (!static_cast<bool>(flags & libdnf5::sack::ExcludeFlags::IGNORE_REGULAR_CONFIG_EXCLUDES) &&
config_excludes.contains(solvable_name_pair.second)) {
sack->p_impl->get_config_group_excludes().contains(it->get_groupid())) {
continue;
}
// Check user excludes
if (!static_cast<bool>(flags & libdnf5::sack::ExcludeFlags::IGNORE_REGULAR_USER_EXCLUDES) &&
user_excludes.contains(solvable_name_pair.second)) {
sack->p_impl->get_user_group_excludes().contains(it->get_groupid())) {
continue;
}
repoid = solvable->repo->name;
// Add installed groups directly, because there is only one solvable for each
if (repoid == "@System") {
Group group(base);
group.add_group_id(GroupId(solvable_id));
add(group);
} else {
// Create map of available groups:
// for each groupid (SOLVABLE_NAME), list all corresponding solvable_ids with repoids
available_map[solvable_name_pair.second].insert(
available_map[solvable_name_pair.second].end(), std::make_pair(repoid, solvable_id));
}
}
// Create groups based on the available_map
for (auto & item : available_map) {
Group group(base);
// Sort the vector of (repoid, solvable_id) pairs by repoid
std::sort(item.second.begin(), item.second.end(), std::greater<>());
// Create group_ids vector from the sorted solvable_ids
for (const auto & solvableid_repoid_pair : item.second) {
group.add_group_id(GroupId(solvableid_repoid_pair.second));
}
add(group);
add({it.get(), &sack->p_impl->group_data_guard});
}
}
@ -142,11 +90,13 @@ GroupQuery::GroupQuery(libdnf5::Base & base, ExcludeFlags flags, bool empty)
GroupQuery::~GroupQuery() = default;
GroupQuery::GroupQuery(const GroupQuery & src) : libdnf5::sack::Query<Group>(src), p_impl(new Impl(*src.p_impl)) {}
GroupQuery::GroupQuery(const GroupQuery & src)
: libdnf5::sack::Query<GroupWeakPtr>(src),
p_impl(new Impl(*src.p_impl)) {}
GroupQuery::GroupQuery(GroupQuery && src) noexcept = default;
GroupQuery & GroupQuery::operator=(const GroupQuery & src) {
libdnf5::sack::Query<Group>::operator=(src);
libdnf5::sack::Query<GroupWeakPtr>::operator=(src);
if (this != &src) {
if (p_impl) {
*p_impl = *src.p_impl;
@ -167,9 +117,9 @@ void GroupQuery::filter_package_name(const std::vector<std::string> & patterns,
for (auto it = get_data().begin(); it != get_data().end();) {
// Copy group so we can call `get_packages()`, this is needed because `it` is from a std::set and thus const
// but `get_packages()` modifies its group (it stores cache of its packages).
Group group = *it;
GroupWeakPtr group = *it;
bool keep = std::ranges::any_of(
group.get_packages(), [&](const auto & pkg) { return match_string(pkg.get_name(), cmp, patterns); });
group->get_packages(), [&](const auto & pkg) { return match_string(pkg.get_name(), cmp, patterns); });
if (keep) {
++it;
} else {

11
libdnf5/repo/repo_sack.cpp
View File

@ -939,17 +939,14 @@ void RepoSack::Impl::fix_group_missing_xml() {
libdnf5::comps::GroupQuery group_query(available_groups);
group_query.filter_groupid(group_id);
if (group_query.size() == 1) {
// GroupQuery is basically a set thus iterators and `.get()` method
// return `const Group` objects.
// To call non-const serialize method we need to make a copy here.
libdnf5::comps::Group group = group_query.get();
auto & group = group_query.get();
auto xml_file_name = comps_xml_dir / (group_id + ".xml");
logger.debug(
"Re-creating installed group \"{}\" definition to file \"{}\".",
group_id,
xml_file_name.string());
try {
group.serialize(xml_file_name);
group->serialize(xml_file_name);
xml_saved = true;
} catch (utils::xml::XMLSaveError & ex) {
logger.debug(ex.what());
@ -975,14 +972,14 @@ void RepoSack::Impl::fix_group_missing_xml() {
libdnf5::comps::EnvironmentQuery environment_query(available_environments);
environment_query.filter_environmentid(environment_id);
if (environment_query.size() == 1) {
libdnf5::comps::Environment environment = environment_query.get();
auto & environment = environment_query.get();
auto xml_file_name = comps_xml_dir / (environment_id + ".xml");
logger.debug(
"Re-creating installed environmental group \"{}\" definition to file \"{}\".",
environment_id,
xml_file_name.string());
try {
environment.serialize(xml_file_name);
environment->serialize(xml_file_name);
xml_saved = true;
} catch (utils::xml::XMLSaveError & ex) {
logger.debug(ex.what());

134
test/libdnf5/comps/test_environment.cpp
View File

@ -42,14 +42,14 @@ void CompsEnvironmentTest::test_load() {
q_minimal_env.filter_installed(false);
q_minimal_env.filter_environmentid("minimal-environment");
auto minimal_env = q_minimal_env.get();
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env.get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install"), minimal_env.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation"), minimal_env.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality."), minimal_env.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität."), minimal_env.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("3"), minimal_env.get_order());
CPPUNIT_ASSERT_EQUAL(3, minimal_env.get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_env.get_installed());
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env->get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install"), minimal_env->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation"), minimal_env->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality."), minimal_env->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität."), minimal_env->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("3"), minimal_env->get_order());
CPPUNIT_ASSERT_EQUAL(3, minimal_env->get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_env->get_installed());
}
@ -59,14 +59,14 @@ void CompsEnvironmentTest::test_load_defaults() {
EnvironmentQuery q_minimal_empty(base);
q_minimal_empty.filter_environmentid("minimal-environment");
auto minimal_empty = q_minimal_empty.get();
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_empty.get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty.get_name());
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty.get_translated_name("ja"));
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty.get_description());
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty.get_translated_description("ja"));
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty.get_order());
CPPUNIT_ASSERT_EQUAL(INT_MAX, minimal_empty.get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_empty.get_installed());
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_empty->get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty->get_name());
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty->get_translated_name("ja"));
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty->get_description());
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty->get_translated_description("ja"));
CPPUNIT_ASSERT_EQUAL(std::string(""), minimal_empty->get_order());
CPPUNIT_ASSERT_EQUAL(INT_MAX, minimal_empty->get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_empty->get_installed());
}
void CompsEnvironmentTest::test_merge() {
@ -79,20 +79,20 @@ void CompsEnvironmentTest::test_merge() {
EnvironmentQuery q_minimal_env(base);
q_minimal_env.filter_environmentid("minimal-environment");
auto minimal_env = q_minimal_env.get();
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env.get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install v2"), minimal_env.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation v2"), minimal_env.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality v2."), minimal_env.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität v2."), minimal_env.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("4"), minimal_env.get_order());
CPPUNIT_ASSERT_EQUAL(4, minimal_env.get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_env.get_installed());
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env->get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install v2"), minimal_env->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation v2"), minimal_env->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality v2."), minimal_env->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität v2."), minimal_env->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("4"), minimal_env->get_order());
CPPUNIT_ASSERT_EQUAL(4, minimal_env->get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_env->get_installed());
std::set<std::string> expected = {"core", "core-2"};
const auto groups = minimal_env.get_groups();
const auto groups = minimal_env->get_groups();
CPPUNIT_ASSERT_EQUAL(expected, std::set<std::string>(groups.begin(), groups.end()));
std::set<std::string> expected_optional = {"guest-agents", "guest-agents-2", "standard"};
const auto optional_groups = minimal_env.get_optional_groups();
const auto optional_groups = minimal_env->get_optional_groups();
CPPUNIT_ASSERT_EQUAL(expected_optional, std::set<std::string>(optional_groups.begin(), optional_groups.end()));
}
@ -107,20 +107,20 @@ void CompsEnvironmentTest::test_merge_when_different_load_order() {
EnvironmentQuery q_minimal_env(base);
q_minimal_env.filter_environmentid("minimal-environment");
auto minimal_env = q_minimal_env.get();
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env.get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install v2"), minimal_env.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation v2"), minimal_env.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality v2."), minimal_env.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität v2."), minimal_env.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("4"), minimal_env.get_order());
CPPUNIT_ASSERT_EQUAL(4, minimal_env.get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_env.get_installed());
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env->get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install v2"), minimal_env->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation v2"), minimal_env->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality v2."), minimal_env->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität v2."), minimal_env->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("4"), minimal_env->get_order());
CPPUNIT_ASSERT_EQUAL(4, minimal_env->get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_env->get_installed());
std::set<std::string> expected = {"core", "core-2"};
const auto groups = minimal_env.get_groups();
const auto groups = minimal_env->get_groups();
CPPUNIT_ASSERT_EQUAL(expected, std::set<std::string>(groups.begin(), groups.end()));
std::set<std::string> expected_optional = {"guest-agents", "guest-agents-2", "standard"};
const auto optional_groups = minimal_env.get_optional_groups();
const auto optional_groups = minimal_env->get_optional_groups();
CPPUNIT_ASSERT_EQUAL(expected_optional, std::set<std::string>(optional_groups.begin(), optional_groups.end()));
}
@ -135,20 +135,20 @@ void CompsEnvironmentTest::test_merge_with_empty() {
EnvironmentQuery q_minimal_empty(base);
q_minimal_empty.filter_environmentid("minimal-environment");
auto minimal_empty = q_minimal_empty.get();
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_empty.get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_empty->get_environmentid());
// attributes are missing in minimal-environment-empty.xml -> original values are kept
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install"), minimal_empty.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation"), minimal_empty.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality."), minimal_empty.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität."), minimal_empty.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("3"), minimal_empty.get_order());
CPPUNIT_ASSERT_EQUAL(3, minimal_empty.get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_empty.get_installed());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install"), minimal_empty->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation"), minimal_empty->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality."), minimal_empty->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität."), minimal_empty->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("3"), minimal_empty->get_order());
CPPUNIT_ASSERT_EQUAL(3, minimal_empty->get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_empty->get_installed());
std::vector<std::string> expected = {"core"};
CPPUNIT_ASSERT_EQUAL(expected, minimal_empty.get_groups());
CPPUNIT_ASSERT_EQUAL(expected, minimal_empty->get_groups());
std::set<std::string> expected_optional = {"guest-agents", "standard"};
const auto optional_groups = minimal_empty.get_optional_groups();
const auto optional_groups = minimal_empty->get_optional_groups();
CPPUNIT_ASSERT_EQUAL(expected_optional, std::set<std::string>(optional_groups.begin(), optional_groups.end()));
}
@ -164,19 +164,19 @@ void CompsEnvironmentTest::test_merge_empty_with_nonempty() {
q_minimal_env.filter_installed(false);
q_minimal_env.filter_environmentid("minimal-environment");
auto minimal_env = q_minimal_env.get();
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env.get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install"), minimal_env.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation"), minimal_env.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality."), minimal_env.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität."), minimal_env.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("3"), minimal_env.get_order());
CPPUNIT_ASSERT_EQUAL(3, minimal_env.get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_env.get_installed());
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env->get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install"), minimal_env->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation"), minimal_env->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality."), minimal_env->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität."), minimal_env->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("3"), minimal_env->get_order());
CPPUNIT_ASSERT_EQUAL(3, minimal_env->get_order_int());
CPPUNIT_ASSERT_EQUAL(false, minimal_env->get_installed());
std::vector<std::string> expected = {"core"};
CPPUNIT_ASSERT_EQUAL(expected, minimal_env.get_groups());
CPPUNIT_ASSERT_EQUAL(expected, minimal_env->get_groups());
std::set<std::string> expected_optional = {"guest-agents", "standard"};
const auto optional_groups = minimal_env.get_optional_groups();
const auto optional_groups = minimal_env->get_optional_groups();
CPPUNIT_ASSERT_EQUAL(expected_optional, std::set<std::string>(optional_groups.begin(), optional_groups.end()));
}
@ -189,20 +189,20 @@ void CompsEnvironmentTest::test_merge_different_translations() {
EnvironmentQuery q_minimal_env(base);
q_minimal_env.filter_environmentid("minimal-environment");
auto minimal_env = q_minimal_env.get();
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env.get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install"), minimal_env.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality."), minimal_env.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("minimal-environment"), minimal_env->get_environmentid());
CPPUNIT_ASSERT_EQUAL(std::string("Minimal Install"), minimal_env->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Basic functionality."), minimal_env->get_description());
// translations that are missing in minimal-environment-different-translations are taken from minimal-environment
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation"), minimal_env.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität."), minimal_env.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Minimale Installation"), minimal_env->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Grundlegende Funktionalität."), minimal_env->get_translated_description("de"));
// translations that are missing in minimal-environment are taken from minimal-environment-different-translations
CPPUNIT_ASSERT_EQUAL(std::string("Vähimmäisasennus"), minimal_env.get_translated_name("fi"));
CPPUNIT_ASSERT_EQUAL(std::string("Perustoiminnot."), minimal_env.get_translated_description("fi"));
CPPUNIT_ASSERT_EQUAL(std::string("Vähimmäisasennus"), minimal_env->get_translated_name("fi"));
CPPUNIT_ASSERT_EQUAL(std::string("Perustoiminnot."), minimal_env->get_translated_description("fi"));
std::vector<std::string> expected = {"core"};
CPPUNIT_ASSERT_EQUAL(expected, minimal_env.get_groups());
CPPUNIT_ASSERT_EQUAL(expected, minimal_env->get_groups());
std::set<std::string> expected_optional = {"guest-agents", "standard"};
const auto optional_groups = minimal_env.get_optional_groups();
const auto optional_groups = minimal_env->get_optional_groups();
CPPUNIT_ASSERT_EQUAL(expected_optional, std::set<std::string>(optional_groups.begin(), optional_groups.end()));
}
@ -215,7 +215,7 @@ void CompsEnvironmentTest::test_serialize() {
auto minimal_env = q_minimal_env.get();
auto serialize_path = std::filesystem::temp_directory_path() / "serialized-standard.xml";
minimal_env.serialize(serialize_path);
minimal_env->serialize(serialize_path);
std::ifstream serialized_stream(serialize_path);
std::string actual;
@ -246,5 +246,5 @@ void CompsEnvironmentTest::test_solvables() {
q_environments.filter_environmentid("core");
auto core = q_environments.get();
CPPUNIT_ASSERT_EQUAL(
std::string("Environment with the same id as an existing group."), core.get_translated_description("de"));
std::string("Environment with the same id as an existing group."), core->get_translated_description("de"));
}

8
test/libdnf5/comps/test_environment_query.cpp
View File

@ -43,7 +43,7 @@ void CompsEnvironmentQueryTest::setUp() {
void CompsEnvironmentQueryTest::test_query_all() {
EnvironmentQuery q_environments(base);
std::vector<Environment> expected = {
std::vector<EnvironmentWeakPtr> expected = {
get_environment("core"), get_environment("custom-environment"), get_environment("minimal-environment")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_environments));
}
@ -53,7 +53,7 @@ void CompsEnvironmentQueryTest::test_query_filter_environmentid() {
// Filter envitonments with id equal to "core"
EnvironmentQuery q_environments(base);
q_environments.filter_environmentid("core");
std::vector<Environment> expected = {get_environment("core")};
std::vector<EnvironmentWeakPtr> expected = {get_environment("core")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_environments));
// Filter envitonments with id containing "environment"
@ -80,7 +80,7 @@ void CompsEnvironmentQueryTest::test_query_filter_name() {
// Filter envitonments with name equal to "Core Environment"
EnvironmentQuery q_environments(base);
q_environments.filter_name("Core Environment");
std::vector<Environment> expected = {get_environment("core")};
std::vector<EnvironmentWeakPtr> expected = {get_environment("core")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_environments));
// Filter envitonments with name containing "Environment"
@ -111,7 +111,7 @@ void CompsEnvironmentQueryTest::test_query_excludes() {
q_excludes1.filter_environmentid("custom-environment");
sack->set_user_environment_excludes(q_excludes1);
EnvironmentQuery q_groups(base);
std::vector<Environment> expected = {get_environment("core"), get_environment("minimal-environment")};
std::vector<EnvironmentWeakPtr> expected = {get_environment("core"), get_environment("minimal-environment")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_groups));
// Add environment "core" to user excludes -> user excludes are groups: "standard", "core"

186
test/libdnf5/comps/test_group.cpp
View File

@ -65,17 +65,17 @@ void CompsGroupTest::test_load() {
q_core.filter_installed(false);
q_core.filter_groupid("core");
auto core = q_core.get();
CPPUNIT_ASSERT_EQUAL(std::string("core"), core.get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core"), core.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Kern"), core.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation"), core.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation"), core.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("1"), core.get_order());
CPPUNIT_ASSERT_EQUAL(1, core.get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("it"), core.get_langonly());
CPPUNIT_ASSERT_EQUAL(false, core.get_uservisible());
CPPUNIT_ASSERT_EQUAL(false, core.get_default());
CPPUNIT_ASSERT_EQUAL(false, core.get_installed());
CPPUNIT_ASSERT_EQUAL(std::string("core"), core->get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core"), core->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Kern"), core->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation"), core->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation"), core->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("1"), core->get_order());
CPPUNIT_ASSERT_EQUAL(1, core->get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("it"), core->get_langonly());
CPPUNIT_ASSERT_EQUAL(false, core->get_uservisible());
CPPUNIT_ASSERT_EQUAL(false, core->get_default());
CPPUNIT_ASSERT_EQUAL(false, core->get_installed());
std::vector<Package> exp_pkgs_core = {
Package("bash", PackageType::MANDATORY, ""),
@ -83,32 +83,32 @@ void CompsGroupTest::test_load() {
Package("dnf", PackageType::DEFAULT, ""),
Package("conditional", PackageType::CONDITIONAL, "nonexistent"),
Package("dnf-plugins-core", PackageType::OPTIONAL, "")};
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core, core.get_packages());
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core, core->get_packages());
GroupQuery q_standard(base);
q_standard.filter_installed(false);
q_standard.filter_groupid("standard");
auto standard = q_standard.get();
CPPUNIT_ASSERT_EQUAL(std::string("standard"), standard.get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Standard"), standard.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("標準"), standard.get_translated_name("ja"));
CPPUNIT_ASSERT_EQUAL(std::string("standard"), standard->get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Standard"), standard->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("標準"), standard->get_translated_name("ja"));
CPPUNIT_ASSERT_EQUAL(
std::string("Common set of utilities that extend the minimal installation."), standard.get_description());
std::string("Common set of utilities that extend the minimal installation."), standard->get_description());
CPPUNIT_ASSERT_EQUAL(
std::string("最小限のインストールを拡張するユーティリティの共通セット"),
standard.get_translated_description("ja"));
CPPUNIT_ASSERT_EQUAL(std::string("1"), standard.get_order());
CPPUNIT_ASSERT_EQUAL(1, standard.get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string(""), standard.get_langonly());
CPPUNIT_ASSERT_EQUAL(false, standard.get_uservisible());
CPPUNIT_ASSERT_EQUAL(false, standard.get_default());
CPPUNIT_ASSERT_EQUAL(false, standard.get_installed());
standard->get_translated_description("ja"));
CPPUNIT_ASSERT_EQUAL(std::string("1"), standard->get_order());
CPPUNIT_ASSERT_EQUAL(1, standard->get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string(""), standard->get_langonly());
CPPUNIT_ASSERT_EQUAL(false, standard->get_uservisible());
CPPUNIT_ASSERT_EQUAL(false, standard->get_default());
CPPUNIT_ASSERT_EQUAL(false, standard->get_installed());
std::vector<Package> exp_pkgs_standard = {
Package("cryptsetup", PackageType::MANDATORY, ""),
Package("chrony", PackageType::CONDITIONAL, "gnome-control-center"),
Package("conditional", PackageType::CONDITIONAL, "nonexistent")};
CPPUNIT_ASSERT_EQUAL(exp_pkgs_standard, standard.get_packages());
CPPUNIT_ASSERT_EQUAL(exp_pkgs_standard, standard->get_packages());
}
@ -118,18 +118,18 @@ void CompsGroupTest::test_load_defaults() {
GroupQuery q_core_empty(base);
q_core_empty.filter_groupid("core");
auto core_empty = q_core_empty.get();
CPPUNIT_ASSERT_EQUAL(std::string("core"), core_empty.get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty.get_name());
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty.get_translated_name("ja"));
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty.get_description());
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty.get_translated_description("ja"));
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty.get_order());
CPPUNIT_ASSERT_EQUAL(INT_MAX, core_empty.get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty.get_langonly());
CPPUNIT_ASSERT_EQUAL(true, core_empty.get_uservisible());
CPPUNIT_ASSERT_EQUAL(false, core_empty.get_default());
CPPUNIT_ASSERT_EQUAL(false, core_empty.get_installed());
CPPUNIT_ASSERT_EQUAL((size_t)0, core_empty.get_packages().size());
CPPUNIT_ASSERT_EQUAL(std::string("core"), core_empty->get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty->get_name());
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty->get_translated_name("ja"));
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty->get_description());
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty->get_translated_description("ja"));
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty->get_order());
CPPUNIT_ASSERT_EQUAL(INT_MAX, core_empty->get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string(""), core_empty->get_langonly());
CPPUNIT_ASSERT_EQUAL(true, core_empty->get_uservisible());
CPPUNIT_ASSERT_EQUAL(false, core_empty->get_default());
CPPUNIT_ASSERT_EQUAL(false, core_empty->get_installed());
CPPUNIT_ASSERT_EQUAL((size_t)0, core_empty->get_packages().size());
}
@ -143,19 +143,19 @@ void CompsGroupTest::test_merge() {
GroupQuery q_core2(base);
q_core2.filter_groupid("core");
auto core2 = q_core2.get();
CPPUNIT_ASSERT_EQUAL(std::string("core"), core2.get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core v2"), core2.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("core"), core2->get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core v2"), core2->get_name());
// When attributes are missing in core-v2.xml, original values are kept
CPPUNIT_ASSERT_EQUAL(std::string("Kern v2"), core2.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation v2"), core2.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation v2"), core2.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("2"), core2.get_order());
CPPUNIT_ASSERT_EQUAL(2, core2.get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("de"), core2.get_langonly());
CPPUNIT_ASSERT_EQUAL(std::string("Kern v2"), core2->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation v2"), core2->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation v2"), core2->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("2"), core2->get_order());
CPPUNIT_ASSERT_EQUAL(2, core2->get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("de"), core2->get_langonly());
// When boolean attributes are missing in core-v2.xml, default values are taken
CPPUNIT_ASSERT_EQUAL(true, core2.get_uservisible());
CPPUNIT_ASSERT_EQUAL(true, core2.get_default());
CPPUNIT_ASSERT_EQUAL(false, core2.get_installed());
CPPUNIT_ASSERT_EQUAL(true, core2->get_uservisible());
CPPUNIT_ASSERT_EQUAL(true, core2->get_default());
CPPUNIT_ASSERT_EQUAL(false, core2->get_installed());
std::vector<Package> exp_pkgs_core2 = {
Package("bash", PackageType::MANDATORY, ""),
@ -163,7 +163,7 @@ void CompsGroupTest::test_merge() {
Package("dnf", PackageType::DEFAULT, ""),
Package("dnf-plugins-core", PackageType::OPTIONAL, ""),
Package("conditional", PackageType::CONDITIONAL, "nonexistent")};
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core2, core2.get_packages());
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core2, core2->get_packages());
}
@ -178,19 +178,19 @@ void CompsGroupTest::test_merge_when_different_load_order() {
GroupQuery q_core2(base);
q_core2.filter_groupid("core");
auto core2 = q_core2.get();
CPPUNIT_ASSERT_EQUAL(std::string("core"), core2.get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core v2"), core2.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("core"), core2->get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core v2"), core2->get_name());
// When attributes are missing in core-v2.xml, original values are kept
CPPUNIT_ASSERT_EQUAL(std::string("Kern v2"), core2.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation v2"), core2.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation v2"), core2.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("2"), core2.get_order());
CPPUNIT_ASSERT_EQUAL(2, core2.get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("de"), core2.get_langonly());
CPPUNIT_ASSERT_EQUAL(std::string("Kern v2"), core2->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation v2"), core2->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation v2"), core2->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("2"), core2->get_order());
CPPUNIT_ASSERT_EQUAL(2, core2->get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("de"), core2->get_langonly());
// When boolean attributes are missing in core-v2.xml, default values are taken
CPPUNIT_ASSERT_EQUAL(true, core2.get_uservisible());
CPPUNIT_ASSERT_EQUAL(true, core2.get_default());
CPPUNIT_ASSERT_EQUAL(false, core2.get_installed());
CPPUNIT_ASSERT_EQUAL(true, core2->get_uservisible());
CPPUNIT_ASSERT_EQUAL(true, core2->get_default());
CPPUNIT_ASSERT_EQUAL(false, core2->get_installed());
std::vector<Package> exp_pkgs_core2 = {
Package("bash", PackageType::MANDATORY, ""),
@ -198,7 +198,7 @@ void CompsGroupTest::test_merge_when_different_load_order() {
Package("dnf", PackageType::DEFAULT, ""),
Package("dnf-plugins-core", PackageType::OPTIONAL, ""),
Package("conditional", PackageType::CONDITIONAL, "nonexistent")};
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core2, core2.get_packages());
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core2, core2->get_packages());
}
@ -213,19 +213,19 @@ void CompsGroupTest::test_merge_with_empty() {
GroupQuery q_core_empty(base);
q_core_empty.filter_groupid("core");
auto core_empty = q_core_empty.get();
CPPUNIT_ASSERT_EQUAL(std::string("core"), core_empty.get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core"), core_empty.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("core"), core_empty->get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core"), core_empty->get_name());
// attributes are missing in core-empty.xml -> original values are kept
CPPUNIT_ASSERT_EQUAL(std::string("Kern"), core_empty.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation"), core_empty.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation"), core_empty.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("1"), core_empty.get_order());
CPPUNIT_ASSERT_EQUAL(1, core_empty.get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("it"), core_empty.get_langonly());
CPPUNIT_ASSERT_EQUAL(std::string("Kern"), core_empty->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation"), core_empty->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation"), core_empty->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("1"), core_empty->get_order());
CPPUNIT_ASSERT_EQUAL(1, core_empty->get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("it"), core_empty->get_langonly());
// boolean attributes are missing in core-empty.xml -> default values are taken
CPPUNIT_ASSERT_EQUAL(true, core_empty.get_uservisible());
CPPUNIT_ASSERT_EQUAL(false, core_empty.get_default());
CPPUNIT_ASSERT_EQUAL(false, core_empty.get_installed());
CPPUNIT_ASSERT_EQUAL(true, core_empty->get_uservisible());
CPPUNIT_ASSERT_EQUAL(false, core_empty->get_default());
CPPUNIT_ASSERT_EQUAL(false, core_empty->get_installed());
std::vector<Package> exp_pkgs_core = {
Package("bash", PackageType::MANDATORY, ""),
@ -233,7 +233,7 @@ void CompsGroupTest::test_merge_with_empty() {
Package("dnf", PackageType::DEFAULT, ""),
Package("conditional", PackageType::CONDITIONAL, "nonexistent"),
Package("dnf-plugins-core", PackageType::OPTIONAL, "")};
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core, core_empty.get_packages());
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core, core_empty->get_packages());
}
@ -247,24 +247,24 @@ void CompsGroupTest::test_merge_empty_with_nonempty() {
GroupQuery q_core(base);
q_core.filter_groupid("core");
auto core = q_core.get();
CPPUNIT_ASSERT_EQUAL(std::string("core"), core.get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core v2"), core.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Kern v2"), core.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation v2"), core.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation v2"), core.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("2"), core.get_order());
CPPUNIT_ASSERT_EQUAL(2, core.get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("de"), core.get_langonly());
CPPUNIT_ASSERT_EQUAL(true, core.get_uservisible());
CPPUNIT_ASSERT_EQUAL(true, core.get_default());
CPPUNIT_ASSERT_EQUAL(false, core.get_installed());
CPPUNIT_ASSERT_EQUAL(std::string("core"), core->get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core v2"), core->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Kern v2"), core->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation v2"), core->get_description());
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation v2"), core->get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("2"), core->get_order());
CPPUNIT_ASSERT_EQUAL(2, core->get_order_int());
CPPUNIT_ASSERT_EQUAL(std::string("de"), core->get_langonly());
CPPUNIT_ASSERT_EQUAL(true, core->get_uservisible());
CPPUNIT_ASSERT_EQUAL(true, core->get_default());
CPPUNIT_ASSERT_EQUAL(false, core->get_installed());
std::vector<Package> exp_pkgs_core = {
Package("bash", PackageType::MANDATORY, ""),
Package("glibc", PackageType::MANDATORY, ""),
Package("dnf", PackageType::DEFAULT, ""),
Package("dnf-plugins-core", PackageType::OPTIONAL, "")};
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core, core.get_packages());
CPPUNIT_ASSERT_EQUAL(exp_pkgs_core, core->get_packages());
}
@ -276,15 +276,15 @@ void CompsGroupTest::test_merge_different_translations() {
GroupQuery q_core(base);
q_core.filter_groupid("core");
auto core = q_core.get();
CPPUNIT_ASSERT_EQUAL(std::string("core"), core.get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core"), core.get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation"), core.get_description());
CPPUNIT_ASSERT_EQUAL(std::string("core"), core->get_groupid());
CPPUNIT_ASSERT_EQUAL(std::string("Core"), core->get_name());
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation"), core->get_description());
// translations that are missing in repomd-comps-core-different-translations are taken from repomd-comps-core
CPPUNIT_ASSERT_EQUAL(std::string("Kern"), core.get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation"), core.get_translated_description("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Kern"), core->get_translated_name("de"));
CPPUNIT_ASSERT_EQUAL(std::string("Kleinstmögliche Installation"), core->get_translated_description("de"));
// translations that are missing in repomd-comps-core are taken from repomd-comps-core-different-translations
CPPUNIT_ASSERT_EQUAL(std::string("Tuum"), core.get_translated_name("et"));
CPPUNIT_ASSERT_EQUAL(std::string("Väikseim võimalik paigaldus"), core.get_translated_description("et"));
CPPUNIT_ASSERT_EQUAL(std::string("Tuum"), core->get_translated_name("et"));
CPPUNIT_ASSERT_EQUAL(std::string("Väikseim võimalik paigaldus"), core->get_translated_description("et"));
}
@ -296,7 +296,7 @@ void CompsGroupTest::test_serialize() {
auto standard = q_standard.get();
auto serialize_path = temp_dir->get_path() / "serialized-standard.xml";
standard.serialize(serialize_path);
standard->serialize(serialize_path);
std::string actual = libdnf5::utils::fs::File(serialize_path, "r").read();
@ -322,5 +322,5 @@ void CompsGroupTest::test_solvables() {
// There is an environment with id core that has a translation for lang "ee", but it shouldn't be used for the group with id core.
q_groups.filter_groupid("core");
auto core = q_groups.get();
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation"), core.get_translated_description("ee"));
CPPUNIT_ASSERT_EQUAL(std::string("Smallest possible installation"), core->get_translated_description("ee"));
}

15
test/libdnf5/comps/test_group_query.cpp
View File

@ -43,7 +43,8 @@ void CompsGroupQueryTest::setUp() {
void CompsGroupQueryTest::test_query_all() {
GroupQuery q_groups(base);
std::vector<Group> expected = {get_group("core"), get_group("critical-path-standard"), get_group("standard")};
std::vector<GroupWeakPtr> expected = {
get_group("core"), get_group("critical-path-standard"), get_group("standard")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_groups));
}
@ -52,7 +53,7 @@ void CompsGroupQueryTest::test_query_filter_groupid() {
// Filter groups with id equal to "standard"
GroupQuery q_groups(base);
q_groups.filter_groupid("standard");
std::vector<Group> expected = {get_group("standard")};
std::vector<GroupWeakPtr> expected = {get_group("standard")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_groups));
// Filter groups with id containing "standard"
@ -85,7 +86,7 @@ void CompsGroupQueryTest::test_query_filter_name() {
// Filter groups with name equal to "Standard"
GroupQuery q_groups(base);
q_groups.filter_name("Standard");
std::vector<Group> expected = {get_group("standard")};
std::vector<GroupWeakPtr> expected = {get_group("standard")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_groups));
// Filter groups with name containing "Standard"
@ -112,7 +113,7 @@ void CompsGroupQueryTest::test_query_filter_uservisible() {
// Filter groups with uservisible=true
GroupQuery q_groups(base);
q_groups.filter_uservisible(true);
std::vector<Group> expected = {get_group("core"), get_group("critical-path-standard")};
std::vector<GroupWeakPtr> expected = {get_group("core"), get_group("critical-path-standard")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_groups));
// Filter groups with uservisible=false
@ -127,7 +128,7 @@ void CompsGroupQueryTest::test_query_filter_default() {
// Filter groups with default=true
GroupQuery q_groups(base);
q_groups.filter_default(true);
std::vector<Group> expected = {get_group("critical-path-standard")};
std::vector<GroupWeakPtr> expected = {get_group("critical-path-standard")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_groups));
// Filter groups with default=false
@ -142,7 +143,7 @@ void CompsGroupQueryTest::test_query_filter_package_name() {
// Filter groups which contain given packages
GroupQuery q_groups(base);
q_groups.filter_package_name(std::vector<std::string>({"chrony"}));
std::vector<Group> expected = {get_group("standard")};
std::vector<GroupWeakPtr> expected = {get_group("standard")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_groups));
q_groups = GroupQuery(base);
@ -160,7 +161,7 @@ void CompsGroupQueryTest::test_query_excludes() {
q_excludes1.filter_groupid("standard");
sack->set_user_group_excludes(q_excludes1);
GroupQuery q_groups(base);
std::vector<Group> expected = {get_group("core"), get_group("critical-path-standard")};
std::vector<GroupWeakPtr> expected = {get_group("core"), get_group("critical-path-standard")};
CPPUNIT_ASSERT_EQUAL(expected, to_vector(q_groups));
// Add group "core" to user excludes -> user excludes are groups: "standard", "core"

9
test/python3/libdnf5/comps/test_group.py
View File

@ -45,3 +45,12 @@ class TestGroup(base_test_case.BaseTestCase):
query = libdnf5.comps.GroupQuery(self.base)
core_group = next(iter(query))
self.assertEqual(5, len(core_group.get_packages()))
def test_group_when_query_out_of_scope(self):
self.add_repo_repomd("repomd-comps-core")
def get_group(base):
query = libdnf5.comps.GroupQuery(base)
return next(iter(query))
self.assertEqual(5, len(get_group(self.base).get_packages()))

16
test/shared/base_test_case.cpp
View File

@ -90,13 +90,13 @@ libdnf5::advisory::Advisory BaseTestCase::get_advisory(const std::string & name)
}
libdnf5::comps::Environment BaseTestCase::get_environment(const std::string & environmentid, bool installed) {
libdnf5::comps::EnvironmentWeakPtr BaseTestCase::get_environment(const std::string & environmentid, bool installed) {
// This is used for testing queries as well, hence we don't use the EnvironmentQuery facility for filtering
libdnf5::Set<libdnf5::comps::Environment> environments = libdnf5::comps::EnvironmentQuery(base);
libdnf5::Set<libdnf5::comps::EnvironmentWeakPtr> environments = libdnf5::comps::EnvironmentQuery(base);
std::set<libdnf5::comps::Environment> found;
std::set<libdnf5::comps::EnvironmentWeakPtr> found;
for (auto environment : environments) {
if (environment.get_environmentid() == environmentid && environment.get_installed() == installed) {
if (environment->get_environmentid() == environmentid && environment->get_installed() == installed) {
found.insert(environment);
}
}
@ -113,13 +113,13 @@ libdnf5::comps::Environment BaseTestCase::get_environment(const std::string & en
}
libdnf5::comps::Group BaseTestCase::get_group(const std::string & groupid, bool installed) {
libdnf5::comps::GroupWeakPtr BaseTestCase::get_group(const std::string & groupid, bool installed) {
// This is used for testing queries as well, hence we don't use the GroupQuery facility for filtering
libdnf5::Set<libdnf5::comps::Group> groups = libdnf5::comps::GroupQuery(base);
libdnf5::Set<libdnf5::comps::GroupWeakPtr> groups = libdnf5::comps::GroupQuery(base);
std::set<libdnf5::comps::Group> found;
std::set<libdnf5::comps::GroupWeakPtr> found;
for (auto group : groups) {
if (group.get_groupid() == groupid && group.get_installed() == installed) {
if (group->get_groupid() == groupid && group->get_installed() == installed) {
found.insert(group);
}
}

4
test/shared/base_test_case.hpp
View File

@ -59,9 +59,9 @@ public:
libdnf5::advisory::Advisory get_advisory(const std::string & name);
libdnf5::comps::Environment get_environment(const std::string & environmentid, bool installed = false);
libdnf5::comps::EnvironmentWeakPtr get_environment(const std::string & environmentid, bool installed = false);
libdnf5::comps::Group get_group(const std::string & groupid, bool installed = false);
libdnf5::comps::GroupWeakPtr get_group(const std::string & groupid, bool installed = false);
libdnf5::rpm::Package get_pkg(const std::string & nevra, bool installed = false);
libdnf5::rpm::Package get_pkg(const std::string & nevra, const char * repo);

14
test/shared/utils.cpp
View File

@ -48,19 +48,25 @@ std::vector<libdnf5::advisory::Advisory> to_vector(const libdnf5::advisory::Advi
}
std::vector<libdnf5::comps::Environment> to_vector(const libdnf5::Set<libdnf5::comps::Environment> & environment_set) {
std::vector<libdnf5::comps::Environment> res;
std::vector<libdnf5::comps::EnvironmentWeakPtr> to_vector(
const libdnf5::Set<libdnf5::comps::EnvironmentWeakPtr> & environment_set) {
std::vector<libdnf5::comps::EnvironmentWeakPtr> res;
for (const auto & environment : environment_set) {
res.push_back(environment);
}
std::sort(res.begin(), res.end(), [](libdnf5::comps::EnvironmentWeakPtr a, libdnf5::comps::EnvironmentWeakPtr b) {
return *a < *b;
});
return res;
}
std::vector<libdnf5::comps::Group> to_vector(const libdnf5::Set<libdnf5::comps::Group> & group_set) {
std::vector<libdnf5::comps::Group> res;
std::vector<libdnf5::comps::GroupWeakPtr> to_vector(const libdnf5::Set<libdnf5::comps::GroupWeakPtr> & group_set) {
std::vector<libdnf5::comps::GroupWeakPtr> res;
for (const auto & group : group_set) {
res.push_back(group);
}
std::sort(
res.begin(), res.end(), [](libdnf5::comps::GroupWeakPtr a, libdnf5::comps::GroupWeakPtr b) { return *a < *b; });
return res;
}

40
test/shared/utils.hpp
View File

@ -102,31 +102,32 @@ struct assertion_traits<libdnf5::advisory::AdvisorySet> {
};
template <>
struct assertion_traits<libdnf5::comps::Environment> {
inline static bool equal(const libdnf5::comps::Environment & left, const libdnf5::comps::Environment & right) {
struct assertion_traits<libdnf5::comps::EnvironmentWeakPtr> {
inline static bool equal(
const libdnf5::comps::EnvironmentWeakPtr & left, const libdnf5::comps::EnvironmentWeakPtr & right) {
return left == right;
}
inline static std::string toString(const libdnf5::comps::Environment & environment) {
inline static std::string toString(const libdnf5::comps::EnvironmentWeakPtr & environment) {
std::string repos;
for (const auto & repo : environment.get_repos()) {
for (const auto & repo : environment->get_repos()) {
if (!repos.empty()) {
repos += ", ";
}
repos += repo;
}
return fmt::format("{} (repos: {})", environment.get_environmentid(), repos);
return fmt::format("{} (repos: {})", environment->get_environmentid(), repos);
}
};
template <>
struct assertion_traits<libdnf5::Set<libdnf5::comps::Environment>> {
inline static std::string toString(const libdnf5::Set<libdnf5::comps::Environment> & environments) {
struct assertion_traits<libdnf5::Set<libdnf5::comps::EnvironmentWeakPtr>> {
inline static std::string toString(const libdnf5::Set<libdnf5::comps::EnvironmentWeakPtr> & environments) {
std::string result;
for (const auto & environment : environments) {
result += "\n " + assertion_traits<libdnf5::comps::Environment>::toString(environment);
result += "\n " + assertion_traits<libdnf5::comps::EnvironmentWeakPtr>::toString(environment);
}
return result;
@ -134,31 +135,31 @@ struct assertion_traits<libdnf5::Set<libdnf5::comps::Environment>> {
};
template <>
struct assertion_traits<libdnf5::comps::Group> {
inline static bool equal(const libdnf5::comps::Group & left, const libdnf5::comps::Group & right) {
return left == right;
struct assertion_traits<libdnf5::comps::GroupWeakPtr> {
inline static bool equal(const libdnf5::comps::GroupWeakPtr & left, const libdnf5::comps::GroupWeakPtr & right) {
return *left == *right;
}
inline static std::string toString(const libdnf5::comps::Group & group) {
inline static std::string toString(const libdnf5::comps::GroupWeakPtr & group) {
std::string repos;
for (const auto & repo : group.get_repos()) {
for (const auto & repo : group->get_repos()) {
if (!repos.empty()) {
repos += ", ";
}
repos += repo;
}
return fmt::format("{} (repos: {})", group.get_groupid(), repos);
return fmt::format("{} (repos: {})", group->get_groupid(), repos);
}
};
template <>
struct assertion_traits<libdnf5::Set<libdnf5::comps::Group>> {
inline static std::string toString(const libdnf5::Set<libdnf5::comps::Group> & groups) {
struct assertion_traits<libdnf5::Set<libdnf5::comps::GroupWeakPtr>> {
inline static std::string toString(const libdnf5::Set<libdnf5::comps::GroupWeakPtr> & groups) {
std::string result;
for (const auto & group : groups) {
result += "\n " + assertion_traits<libdnf5::comps::Group>::toString(group);
result += "\n " + assertion_traits<libdnf5::comps::GroupWeakPtr>::toString(group);
}
return result;
@ -343,8 +344,9 @@ struct assertion_traits<libdnf5::transaction::EnvironmentReplay> {
std::vector<libdnf5::advisory::Advisory> to_vector(const libdnf5::advisory::AdvisorySet & advisory_set);
std::vector<libdnf5::comps::Environment> to_vector(const libdnf5::Set<libdnf5::comps::Environment> & environment_set);
std::vector<libdnf5::comps::Group> to_vector(const libdnf5::Set<libdnf5::comps::Group> & group_set);
std::vector<libdnf5::comps::EnvironmentWeakPtr> to_vector(
const libdnf5::Set<libdnf5::comps::EnvironmentWeakPtr> & environment_set);
std::vector<libdnf5::comps::GroupWeakPtr> to_vector(const libdnf5::Set<libdnf5::comps::GroupWeakPtr> & group_set);
std::vector<libdnf5::rpm::Reldep> to_vector(const libdnf5::rpm::ReldepList & reldep_list);
std::vector<libdnf5::rpm::Package> to_vector(const libdnf5::rpm::PackageSet & package_set);