END_TEST
START_TEST(test_goal_installonly_limit_with_modules)
{
// most complex installonly test case, includes the k-m packages
const char *installonly[] = {"k", "k-m", NULL};
DnfSack *sack = test_globals.sack;
dnf_sack_set_installonly(sack, installonly);
dnf_sack_set_installonly_limit(sack, 3);
dnf_sack_set_running_kernel_fn(sack, mock_running_kernel);
HyGoal goal = hy_goal_create(sack);
hy_goal_upgrade_all(goal);
fail_if(hy_goal_run_flags(goal, 0));
assert_iueo(goal, 2, 0, 5, 0);
GPtrArray *erasures = hy_goal_list_erasures(goal, NULL);
assert_nevra_eq(g_ptr_array_index(erasures, 0), "k-1-0.x86_64");
assert_nevra_eq(g_ptr_array_index(erasures, 1), "k-m-1-0.x86_64");
assert_nevra_eq(g_ptr_array_index(erasures, 2), "k-freak-1-0-1-0.x86_64");
assert_nevra_eq(g_ptr_array_index(erasures, 3), "k-2-0.x86_64");
assert_nevra_eq(g_ptr_array_index(erasures, 4), "k-m-2-0.x86_64");
g_ptr_array_unref(erasures);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_installonly_limit_with_modules)
{
// most complex installonly test case, includes the k-m packages
const char *installonly[] = {"k", "k-m", NULL};
HySack sack = test_globals.sack;
hy_sack_set_installonly(sack, installonly);
hy_sack_set_installonly_limit(sack, 3);
sack->running_kernel_fn = mock_running_kernel;
HyGoal goal = hy_goal_create(sack);
hy_goal_upgrade_all(goal);
fail_if(hy_goal_run_flags(goal, 0));
assert_iueo(goal, 2, 0, 5, 0);
HyPackageList erasures = hy_goal_list_erasures(goal);
assert_nevra_eq(hy_packagelist_get(erasures, 0), "k-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 1), "k-m-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 2), "k-freak-1-0-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 3), "k-2-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 4), "k-m-2-0.x86_64");
hy_packagelist_free(erasures);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_verify)
{
g_autoptr(GError) error = NULL;
DnfSack *sack = test_globals.sack;
HyGoal goal = hy_goal_create(sack);
fail_unless(hy_goal_run_flags(goal, DNF_VERIFY));
fail_unless(hy_goal_list_installs(goal, &error) == NULL);
fail_unless(error->code == DNF_ERROR_NO_SOLUTION);
fail_unless(hy_goal_count_problems(goal) == 2);
const char *expected;
char *problem;
problem = hy_goal_describe_problem(goal, 0);
expected = "nothing provides missing-dep needed by missing-1-0.x86_64";
fail_if(strncmp(problem, expected, strlen(expected)));
g_free(problem);
problem = hy_goal_describe_problem(goal, 1);
expected = "package conflict-1-0.x86_64 conflicts with ok provided by ok-1-0.x86_64";
fail_if(strncmp(problem, expected, strlen(expected)));
g_free(problem);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_verify)
{
HySack sack = test_globals.sack;
HyGoal goal = hy_goal_create(sack);
fail_unless(hy_goal_run_flags(goal, HY_VERIFY));
fail_unless(hy_goal_list_installs(goal) == NULL);
fail_unless(hy_get_errno() == HY_E_NO_SOLUTION);
fail_unless(hy_goal_count_problems(goal) == 2);
char *expected;
char *problem;
problem = hy_goal_describe_problem(goal, 0);
expected = "nothing provides missing-dep needed by missing-1-0.x86_64";
fail_if(strncmp(problem, expected, strlen(expected)));
hy_free(problem);
problem = hy_goal_describe_problem(goal, 1);
expected = "package conflict-1-0.x86_64 conflicts with ok provided by ok-1-0.x86_64";
fail_if(strncmp(problem, expected, strlen(expected)));
hy_free(problem);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_protected)
{
DnfSack *sack = test_globals.sack;
DnfPackageSet *protected = dnf_packageset_new(sack);
DnfPackage *pkg = by_name_repo(sack, "penny-lib", HY_SYSTEM_REPO_NAME);
DnfPackage *pp = by_name_repo(sack, "flying", HY_SYSTEM_REPO_NAME);
const char *expected;
g_autofree gchar *problem;
// when protected_packages set is empty it should remove both packages
HyGoal goal = hy_goal_create(sack);
DnfPackageSet *empty = dnf_packageset_new(sack);
dnf_goal_set_protected(goal, empty);
g_object_unref(empty);
hy_goal_erase(goal, pkg);
fail_if(hy_goal_run_flags(goal, DNF_ALLOW_UNINSTALL));
assert_iueo(goal, 0, 0, 2, 0);
hy_goal_free(goal);
// fails to uninstall penny-lib because flying is protected
goal = hy_goal_create(sack);
dnf_packageset_add(protected, pp);
dnf_goal_set_protected(goal, protected);
hy_goal_erase(goal, pkg);
fail_unless(hy_goal_run_flags(goal, DNF_ALLOW_UNINSTALL));
hy_goal_free(goal);
// removal of protected package explicitly should trigger error
goal = hy_goal_create(sack);
dnf_goal_set_protected(goal, protected);
hy_goal_erase(goal, pp);
fail_unless(hy_goal_run(goal));
fail_unless(hy_goal_count_problems(goal) == 1);
problem = hy_goal_describe_problem(goal, 0);
expected = "The operation would result in removing "
"the following protected packages: flying";
fail_if(g_strcmp0(problem, expected));
hy_goal_free(goal);
g_object_unref(protected);
g_object_unref(pkg);
g_object_unref(pp);
}
END_TEST
START_TEST(test_cmdline_file_provides)
{
HySack sack = test_globals.sack;
HyGoal goal = hy_goal_create(sack);
hy_goal_upgrade_all(goal);
ck_assert(!hy_goal_run_flags(goal, HY_FORCE_BEST));
assert_iueo(goal, 0, 1, 0, 0);
hy_goal_free(goal);
}
static PyObject *
run(_GoalObject *self, PyObject *args, PyObject *kwds)
{
int flags = 0;
if (!args_run_parse(args, kwds, &flags, NULL))
return NULL;
int ret = hy_goal_run_flags(self->goal, flags);
if (!ret)
Py_RETURN_TRUE;
Py_RETURN_FALSE;
}
END_TEST
START_TEST(test_cmdline_file_provides)
{
DnfSack *sack = test_globals.sack;
dnf_sack_set_running_kernel_fn(sack, mock_running_kernel_no);
HyGoal goal = hy_goal_create(sack);
hy_goal_upgrade_all(goal);
ck_assert(!hy_goal_run_flags(goal, DNF_FORCE_BEST));
assert_iueo(goal, 0, 1, 0, 0);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_kernel_protected)
{
DnfSack *sack = test_globals.sack;
dnf_sack_set_running_kernel_fn(sack, mock_running_kernel);
Id kernel_id = mock_running_kernel(sack);
DnfPackage *kernel = dnf_package_new(sack, kernel_id);
HyGoal goal = hy_goal_create(sack);
hy_goal_erase(goal, kernel);
fail_unless(hy_goal_run_flags(goal, 0));
g_object_unref(kernel);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_forcebest_arches)
{
DnfSack *sack = test_globals.sack;
HyGoal goal = hy_goal_create(sack);
HySelector sltr = hy_selector_create(sack);
hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "gun");
fail_if(hy_goal_upgrade_selector(goal, sltr));
fail_if(hy_goal_run_flags(goal, DNF_FORCE_BEST));
assert_iueo(goal, 0, 0, 0, 0);
hy_selector_free(sltr);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_forcebest)
{
DnfSack *sack = test_globals.sack;
HyGoal goal = hy_goal_create(sack);
HySelector sltr = hy_selector_create(sack);
hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "flying");
hy_goal_upgrade_selector(goal, sltr);
fail_unless(hy_goal_run_flags(goal, DNF_FORCE_BEST));
fail_unless(hy_goal_count_problems(goal) == 1);
hy_selector_free(sltr);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_installonly_limit_disabled)
{
// test that setting limit to 0 does not cause all intallonlies to be
// uninstalled
const char *installonly[] = {"k", NULL};
DnfSack *sack = test_globals.sack;
dnf_sack_set_installonly(sack, installonly);
dnf_sack_set_installonly_limit(sack, 0);
dnf_sack_set_running_kernel_fn(sack, mock_running_kernel_no);
HyGoal goal = hy_goal_create(sack);
hy_goal_upgrade_all(goal);
fail_if(hy_goal_run_flags(goal, 0));
assert_iueo(goal, 1, 1, 0, 0);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_install_weak_deps)
{
HySelector sltr = hy_selector_create(test_globals.sack);
hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "B");
HyGoal goal = hy_goal_create(test_globals.sack);
fail_if(!hy_goal_install_selector(goal, sltr, NULL));
HyGoal goal2 = hy_goal_clone(goal);
fail_if(hy_goal_run(goal));
// recommended package C is installed too
assert_iueo(goal, 2, 0, 0, 0);
fail_if(hy_goal_run_flags(goal2, DNF_IGNORE_WEAK_DEPS));
assert_iueo(goal2, 1, 0, 0, 0);
hy_goal_free(goal);
hy_goal_free(goal2);
hy_selector_free(sltr);
}
END_TEST
START_TEST(test_goal_erase_with_deps)
{
DnfSack *sack = test_globals.sack;
DnfPackage *pkg = by_name_repo(sack, "penny-lib", HY_SYSTEM_REPO_NAME);
// by default can not remove penny-lib, flying depends on it:
HyGoal goal = hy_goal_create(sack);
hy_goal_erase(goal, pkg);
fail_unless(hy_goal_run(goal));
hy_goal_free(goal);
goal = hy_goal_create(sack);
hy_goal_erase(goal, pkg);
fail_if(hy_goal_run_flags(goal, DNF_ALLOW_UNINSTALL));
assert_iueo(goal, 0, 0, 2, 0);
hy_goal_free(goal);
g_object_unref(pkg);
}
END_TEST
START_TEST(test_goal_get_solution)
{
DnfSack *sack = test_globals.sack;
HyGoal goal = hy_goal_create(sack);
HySelector sltr = hy_selector_create(sack);
hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "pilchard");
hy_goal_install_selector(goal, sltr,NULL);
hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "dog");
hy_goal_install_selector(goal, sltr,NULL);
hy_selector_set(sltr, HY_PKG_NAME, HY_EQ, "custard");
hy_goal_install_selector(goal, sltr,NULL);
fail_unless(hy_goal_run_flags(goal, DNF_FORCE_BEST));
fail_unless(hy_goal_count_problems(goal) == 2);
DnfSolutionAction expected_actions[2][3] = {
{DNF_SOLUTION_ACTION_DO_NOT_INSTALL, 0, 0},
{DNF_SOLUTION_ACTION_ALLOW_REMOVE,
DNF_SOLUTION_ACTION_DO_NOT_REMOVE,
DNF_SOLUTION_ACTION_DO_NOT_INSTALL}};
const gchar *expected_old[2][3] = {{NULL, NULL, NULL},
{"pilchard-1.2.3-1.i686", "pilchard-1.2.3-1.i686", NULL}};
const gchar *expected_new[2][3] = {{"custard", NULL, NULL},
{NULL, NULL, "pilchard"}};
for (gint p = 0; p < hy_goal_count_problems(goal); ++p) {
g_autoptr(GPtrArray) slist = hy_goal_get_solution(goal, p);
for (guint i = 0; i < slist->len; ++i) {
DnfSolution *sol = g_ptr_array_index(slist, i);
fail_unless(dnf_solution_get_action(sol) == expected_actions[p][i]);
fail_unless(g_strcmp0(dnf_solution_get_old(sol), expected_old[p][i]) == 0);
fail_unless(g_strcmp0(dnf_solution_get_new(sol), expected_new[p][i]) == 0);
}
}
hy_selector_free(sltr);
hy_goal_free(goal);
}
/**
* hif_goal_depsolve:
*/
gboolean
hif_goal_depsolve (HyGoal goal, GError **error)
{
gchar *tmp;
gint cnt;
gint j;
gint rc;
_cleanup_string_free_ GString *string = NULL;
rc = hy_goal_run_flags (goal, HY_ALLOW_UNINSTALL);
if (rc) {
string = g_string_new ("Could not depsolve transaction; ");
cnt = hy_goal_count_problems (goal);
if (cnt == 1)
g_string_append_printf (string, "%i problem detected:\n", cnt);
else
g_string_append_printf (string, "%i problems detected:\n", cnt);
for (j = 0; j < cnt; j++) {
tmp = hy_goal_describe_problem (goal, j);
g_string_append_printf (string, "%i. %s\n", j, tmp);
hy_free (tmp);
}
g_string_truncate (string, string->len - 1);
g_set_error_literal (error,
HIF_ERROR,
HIF_ERROR_PACKAGE_CONFLICTS,
string->str);
return FALSE;
}
/* anything to do? */
if (hy_goal_req_length (goal) == 0) {
g_set_error_literal (error,
HIF_ERROR,
HIF_ERROR_NO_PACKAGES_TO_UPDATE,
"The transaction was empty");
return FALSE;
}
return TRUE;
}
END_TEST
START_TEST(test_goal_installonly_limit)
{
const char *installonly[] = {"k", NULL};
DnfSack *sack = test_globals.sack;
dnf_sack_set_installonly(sack, installonly);
dnf_sack_set_installonly_limit(sack, 3);
dnf_sack_set_running_kernel_fn(sack, mock_running_kernel_no);
HyGoal goal = hy_goal_create(sack);
hy_goal_upgrade_all(goal);
fail_if(hy_goal_run_flags(goal, 0));
assert_iueo(goal, 1, 1, 3, 0); // k-m is just upgraded
GPtrArray *erasures = hy_goal_list_erasures(goal, NULL);
assert_nevra_eq(g_ptr_array_index(erasures, 0), "k-1-0.x86_64");
assert_nevra_eq(g_ptr_array_index(erasures, 1), "k-freak-1-0-1-0.x86_64");
assert_nevra_eq(g_ptr_array_index(erasures, 2), "k-1-1.x86_64");
g_ptr_array_unref(erasures);
hy_goal_free(goal);
}
END_TEST
START_TEST(test_goal_installonly_limit)
{
const char *installonly[] = {"k", NULL};
HySack sack = test_globals.sack;
hy_sack_set_installonly(sack, installonly);
hy_sack_set_installonly_limit(sack, 3);
sack->running_kernel_fn = mock_running_kernel_no;
HyGoal goal = hy_goal_create(sack);
hy_goal_upgrade_all(goal);
fail_if(hy_goal_run_flags(goal, 0));
assert_iueo(goal, 1, 1, 3, 0); // k-m is just upgraded
HyPackageList erasures = hy_goal_list_erasures(goal);
assert_nevra_eq(hy_packagelist_get(erasures, 0), "k-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 1), "k-freak-1-0-1-0.x86_64");
assert_nevra_eq(hy_packagelist_get(erasures, 2), "k-1-1.x86_64");
hy_packagelist_free(erasures);
hy_goal_free(goal);
}
uint32_t
TDNFGoal(
PTDNF pTdnf,
HyPackageList hPkgList,
HySelector hSelector,
TDNF_ALTERTYPE nResolveFor,
PTDNF_SOLVED_PKG_INFO pInfo
)
{
uint32_t dwError = 0;
HyGoal hGoal = NULL;
HyPackage hPkg = NULL;
PTDNF_PKG_INFO pPkgsToInstall = NULL;
PTDNF_PKG_INFO pPkgsToUpgrade = NULL;
PTDNF_PKG_INFO pPkgsToDowngrade = NULL;
PTDNF_PKG_INFO pPkgsToRemove = NULL;
PTDNF_PKG_INFO pPkgsUnNeeded = NULL;
PTDNF_PKG_INFO pPkgsToReinstall = NULL;
int nFlags = 0;
int nRequirePkgList =
(nResolveFor != ALTER_UPGRADEALL &&
nResolveFor != ALTER_DISTRO_SYNC);
if(!pTdnf || !pInfo )
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(nResolveFor == ALTER_UPGRADE && !hSelector)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
if(nRequirePkgList)
{
if(!hPkgList)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
hPkg = hy_packagelist_get(hPkgList, 0);
if(!hPkg)
{
dwError = ERROR_TDNF_PACKAGELIST_EMPTY;
BAIL_ON_TDNF_ERROR(dwError);
}
}
hGoal = hy_goal_create(pTdnf->hSack);
if(!hGoal)
{
dwError = ERROR_TDNF_GOAL_CREATE;
BAIL_ON_TDNF_ERROR(dwError);
}
switch(nResolveFor)
{
case ALTER_DOWNGRADE:
dwError = hy_goal_downgrade_to(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_ERASE:
dwError = hy_goal_erase(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_REINSTALL:
dwError = hy_goal_install(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_INSTALL:
dwError = TDNFPackageGetLatest(hPkgList, &hPkg);
BAIL_ON_TDNF_ERROR(dwError);
dwError = hy_goal_install(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_UPGRADE:
dwError = hy_goal_upgrade_to_selector(hGoal, hSelector);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_UPGRADEALL:
dwError = hy_goal_upgrade_all(hGoal);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_DISTRO_SYNC:
dwError = hy_goal_distupgrade_all(hGoal);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
case ALTER_AUTOERASE:
dwError = TDNFGoalSetUserInstalled(hGoal, hPkgList);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
break;
default:
dwError = ERROR_TDNF_INVALID_RESOLVE_ARG;
BAIL_ON_TDNF_ERROR(dwError);
}
if(pTdnf->pArgs->nBest)
{
nFlags = nFlags | HY_FORCE_BEST;
}
if(pTdnf->pArgs->nAllowErasing ||
nResolveFor == ALTER_ERASE ||
nResolveFor == ALTER_AUTOERASE)
{
nFlags = nFlags | HY_ALLOW_UNINSTALL;
}
dwError = hy_goal_run_flags(hGoal, nFlags);
if(pTdnf->pArgs->nDebugSolver)
{
hy_goal_write_debugdata(hGoal, "debugdata");
}
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_installs(hGoal),
&pPkgsToInstall);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_upgrades(hGoal),
&pPkgsToUpgrade);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_downgrades(hGoal),
&pPkgsToDowngrade);
BAIL_ON_TDNF_ERROR(dwError);
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_erasures(hGoal),
&pPkgsToRemove);
BAIL_ON_TDNF_ERROR(dwError);
if(nResolveFor == ALTER_AUTOERASE)
{
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_unneeded(hGoal),
&pPkgsUnNeeded);
BAIL_ON_TDNF_ERROR(dwError);
}
dwError = TDNFGoalGetResultsIgnoreNoData(
hy_goal_list_reinstalls(hGoal),
&pPkgsToReinstall);
BAIL_ON_TDNF_ERROR(dwError);
pInfo->pPkgsToInstall = pPkgsToInstall;
pInfo->pPkgsToUpgrade = pPkgsToUpgrade;
pInfo->pPkgsToDowngrade = pPkgsToDowngrade;
pInfo->pPkgsToRemove = pPkgsToRemove;
pInfo->pPkgsUnNeeded = pPkgsUnNeeded;
pInfo->pPkgsToReinstall = pPkgsToReinstall;
pTdnf->hGoal = hGoal;
cleanup:
return dwError;
error:
if(hGoal)
{
TDNFGoalReportProblems(hGoal);
hy_goal_free(hGoal);
}
if(pPkgsToInstall)
{
TDNFFreePackageInfo(pPkgsToInstall);
}
if(pPkgsToUpgrade)
{
TDNFFreePackageInfo(pPkgsToUpgrade);
}
if(pPkgsToDowngrade)
{
TDNFFreePackageInfo(pPkgsToDowngrade);
}
if(pPkgsToRemove)
{
TDNFFreePackageInfo(pPkgsToRemove);
}
if(pPkgsUnNeeded)
{
TDNFFreePackageInfo(pPkgsUnNeeded);
}
if(pPkgsToReinstall)
{
TDNFFreePackageInfo(pPkgsToReinstall);
}
goto cleanup;
}
fprintf(stdout, "Found %d packages\n", hy_packagelist_count(hPkgList));
hGoal = hy_goal_create(hSack);
if(!hGoal)
{
dwError = ERROR_TDNF_INVALID_PARAMETER;
BAIL_ON_TDNF_ERROR(dwError);
}
FOR_PACKAGELIST(hPkg, hPkgList, i)
{
dwError = hy_goal_install(hGoal, hPkg);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
dwError = hy_goal_run_flags(hGoal, HY_ALLOW_UNINSTALL);
if(dwError)
{
TDNFGoalReportProblems(hGoal);
BAIL_ON_TDNF_HAWKEY_ERROR(dwError);
}
cleanup:
if(pDir)
{
g_dir_close(pDir);
}
if(pszRPMPath)
{
g_free(pszRPMPath);
}