diff --git a/docs/IPC.md b/docs/IPC.md index 04cdd84761..c4722107f9 100644 --- a/docs/IPC.md +++ b/docs/IPC.md @@ -259,6 +259,10 @@ Every operation payload carries `systemRestartRequired`: `true` when the operati the machine must be restarted before the change takes effect. See [Pending machine restarts](#pending-machine-restarts). +A failed update also carries `updateRefusedByPublisher`: `true` when the package manager refused the +update because the package's publisher requires it to be updated another way (WinGet's +`UpgradeBehavior: deny`). Retrying cannot succeed; `package ignored add` stops it from being offered. + | Method | Path | Auth | Parameters/body | CLI equivalent | | --- | --- | --- | --- | --- | | `GET` | `/uniget/v1/operations` | Yes | None | `operation list` | diff --git a/src/Languages/lang_en.json b/src/Languages/lang_en.json index 2307718e9d..4d55d3b4ae 100644 --- a/src/Languages/lang_en.json +++ b/src/Languages/lang_en.json @@ -1318,6 +1318,7 @@ "{package} may already be up to date, or no installer matches this system": "{package} may already be up to date, or no installer matches this system", "{package} could not be updated because its package source was busy or unreachable. Try again in a few minutes": "{package} could not be updated because its package source was busy or unreachable. Try again in a few minutes", "{package} is currently running. Close it and try again": "{package} is currently running. Close it and try again", + "WinGet cannot update {package}. Its publisher requires updating it another way, for example from within the app itself": "WinGet cannot update {package}. Its publisher requires updating it another way, for example from within the app itself", "{package} Uninstall": "{package} Uninstall", "{0} is being uninstalled": "{0} is being uninstalled", "Uninstall succeeded": "Uninstall succeeded", diff --git a/src/UniGetUI.Avalonia/Infrastructure/AvaloniaOperationRegistry.cs b/src/UniGetUI.Avalonia/Infrastructure/AvaloniaOperationRegistry.cs index 664d017e5d..f97285963d 100644 --- a/src/UniGetUI.Avalonia/Infrastructure/AvaloniaOperationRegistry.cs +++ b/src/UniGetUI.Avalonia/Infrastructure/AvaloniaOperationRegistry.cs @@ -13,6 +13,7 @@ using UniGetUI.Interface; using UniGetUI.PackageEngine.Classes.Packages.Classes; using UniGetUI.PackageEngine.Enums; +using UniGetUI.PackageEngine.Operations; using UniGetUI.PackageEngine.Operations.History; using UniGetUI.PackageOperations; @@ -118,7 +119,8 @@ public static void Add(AbstractOperation op) public static void RetryFailed() { var failed = OperationViewModels - .Where(vm => vm.Operation.Status is OperationStatus.Failed) + .Where(vm => vm.Operation.Status is OperationStatus.Failed + && PackageOperation.IsWorthRetryingInBulk(vm.Operation)) .ToList(); foreach (var vm in failed) vm.Operation.Retry(AbstractOperation.RetryMode.Retry); diff --git a/src/UniGetUI.Avalonia/ViewModels/DialogPages/OperationViewModel.cs b/src/UniGetUI.Avalonia/ViewModels/DialogPages/OperationViewModel.cs index 60566359f0..5df45f3ca1 100644 --- a/src/UniGetUI.Avalonia/ViewModels/DialogPages/OperationViewModel.cs +++ b/src/UniGetUI.Avalonia/ViewModels/DialogPages/OperationViewModel.cs @@ -19,6 +19,7 @@ using UniGetUI.PackageEngine.Enums; using UniGetUI.PackageEngine.Operations; using UniGetUI.PackageEngine.PackageClasses; +using UniGetUI.PackageEngine.PackageLoader; using UniGetUI.PackageOperations; namespace UniGetUI.Avalonia.ViewModels; @@ -293,6 +294,10 @@ private void RebuildMenu(OperationStatus status) } else { + if (Operation is PackageOperation ignorableOp && PackageOperation.CanIgnoreUpdatesAfterFailure(ignorableOp)) + OpMenu.Items.Add(Item("Ignore updates for this package", "pin.svg", true, + () => _ = UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(ignorableOp.Package))); + OpMenu.Items.Add(Item("Retry", "reload.svg", true, () => Operation.Retry(AbstractOperation.RetryMode.Retry))); diff --git a/src/UniGetUI.Avalonia/Views/DialogPages/OperationFailedDialog.axaml.cs b/src/UniGetUI.Avalonia/Views/DialogPages/OperationFailedDialog.axaml.cs index a9c4b4b343..8b58dfa678 100644 --- a/src/UniGetUI.Avalonia/Views/DialogPages/OperationFailedDialog.axaml.cs +++ b/src/UniGetUI.Avalonia/Views/DialogPages/OperationFailedDialog.axaml.cs @@ -8,6 +8,7 @@ using UniGetUI.Core.Tools; using UniGetUI.PackageEngine.Enums; using UniGetUI.PackageEngine.Operations; +using UniGetUI.PackageEngine.PackageLoader; using UniGetUI.PackageOperations; namespace UniGetUI.Avalonia.Views.DialogPages; @@ -41,11 +42,13 @@ public OperationFailedDialog(AbstractOperation operation) }; closeButton.Click += (_, _) => Close(); - var retryButton = BuildRetryButton(operation); + var primaryButton = operation is PackageOperation pkgOp && PackageOperation.CanIgnoreUpdatesAfterFailure(pkgOp) + ? BuildIgnoreUpdatesButton(pkgOp) + : BuildRetryButton(operation); - ButtonsLayout.Children.Add(retryButton); + ButtonsLayout.Children.Add(primaryButton); ButtonsLayout.Children.Add(closeButton); - Grid.SetColumn(retryButton, 0); + Grid.SetColumn(primaryButton, 0); Grid.SetColumn(closeButton, 1); } @@ -82,6 +85,30 @@ protected override void OnOpened(EventArgs e) Dispatcher.UIThread.Post(OutputText.ScrollToBottom, DispatcherPriority.Background); } + private Control BuildIgnoreUpdatesButton(PackageOperation operation) + { + var button = new SplitButton + { + Content = CoreTools.Translate("Ignore updates for this package"), + HorizontalAlignment = HorizontalAlignment.Stretch, + HorizontalContentAlignment = HorizontalAlignment.Center, + Classes = { "operation-dialog-action" }, + }; + button.Click += async (_, _) => + { + Close(); + await UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(operation.Package); + }; + + var flyout = new MenuFlyout(); + flyout.Items.Add(MenuItem(CoreTools.Translate("Retry"), + () => { operation.Retry(AbstractOperation.RetryMode.Retry); Close(); })); + foreach (var item in CollectRetryMenuItems(operation)) + flyout.Items.Add(item); + button.Flyout = flyout; + return button; + } + private Control BuildRetryButton(AbstractOperation operation) { var retryOptions = CollectRetryMenuItems(operation); diff --git a/src/UniGetUI.Avalonia/Views/SoftwarePages/SoftwareUpdatesPage.cs b/src/UniGetUI.Avalonia/Views/SoftwarePages/SoftwareUpdatesPage.cs index 1196bf1702..aaf568908c 100644 --- a/src/UniGetUI.Avalonia/Views/SoftwarePages/SoftwareUpdatesPage.cs +++ b/src/UniGetUI.Avalonia/Views/SoftwarePages/SoftwareUpdatesPage.cs @@ -114,11 +114,7 @@ protected override void GenerateToolBar(PackagesPageViewModel vm) if (MainWindow.Instance is not { } window || !await IgnoreUpdatesConfirmationDialog.ConfirmAsync(window, packages)) return; foreach (var pkg in packages) - { - await pkg.AddToIgnoredUpdatesAsync(); - UpgradablePackagesLoader.Instance.Remove(pkg); - UpgradablePackagesLoader.Instance.IgnoredPackages[pkg.Id] = pkg; - } + await UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(pkg); }); EnableWhen(ignoreButton, () => HasCheckedPackages); ViewModel.AddToolbarButton("clipboard_list", CoreTools.Translate("Manage ignored updates"), @@ -208,9 +204,7 @@ protected override void GenerateToolBar(PackagesPageViewModel vm) { var pkg = SelectedItem; if (pkg is null) return; - _ = pkg.AddToIgnoredUpdatesAsync(); - UpgradablePackagesLoader.Instance.Remove(pkg); - UpgradablePackagesLoader.Instance.IgnoredPackages[pkg.Id] = pkg; + _ = UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(pkg); }; var menuSkipVersion = new MenuItem @@ -222,9 +216,7 @@ protected override void GenerateToolBar(PackagesPageViewModel vm) { var pkg = SelectedItem; if (pkg is null) return; - _ = pkg.AddToIgnoredUpdatesAsync(pkg.NewVersionString); - UpgradablePackagesLoader.Instance.Remove(pkg); - UpgradablePackagesLoader.Instance.IgnoredPackages[pkg.Id] = pkg; + _ = UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(pkg, pkg.NewVersionString); }; // ── Pause updates submenu ────────────────────────────────────────── @@ -251,9 +243,7 @@ protected override void GenerateToolBar(PackagesPageViewModel vm) { var pkg = SelectedItem; if (pkg is null) return; - _ = pkg.AddToIgnoredUpdatesAsync("<" + t.GetDateFromNow()); - UpgradablePackagesLoader.Instance.IgnoredPackages[pkg.Id] = pkg; - UpgradablePackagesLoader.Instance.Remove(pkg); + _ = UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(pkg, "<" + t.GetDateFromNow()); }; menuPause.Items.Add(item); } diff --git a/src/UniGetUI.Interface.IpcApi/IpcOperationApi.cs b/src/UniGetUI.Interface.IpcApi/IpcOperationApi.cs index 22d9e59314..37e06e5c09 100644 --- a/src/UniGetUI.Interface.IpcApi/IpcOperationApi.cs +++ b/src/UniGetUI.Interface.IpcApi/IpcOperationApi.cs @@ -27,6 +27,7 @@ public class IpcOperationInfo public bool CanForget { get; set; } public IReadOnlyList AvailableQueueActions { get; set; } = []; public IReadOnlyList AvailableRetryModes { get; set; } = []; + public bool UpdateRefusedByPublisher { get; set; } public IpcPackageInfo? Package { get; set; } public string ManagerName { get; set; } = ""; public string SourceName { get; set; } = ""; @@ -217,6 +218,7 @@ public static IpcOperationDetails GetOperation(string operationId) CanForget = info.CanForget, AvailableQueueActions = info.AvailableQueueActions, AvailableRetryModes = info.AvailableRetryModes, + UpdateRefusedByPublisher = info.UpdateRefusedByPublisher, Package = info.Package, ManagerName = info.ManagerName, SourceName = info.SourceName, @@ -359,6 +361,9 @@ private static IpcOperationInfo CreateOperationInfo(TrackedOperation tracked) ? ["run-now", "run-next", "run-last"] : [], AvailableRetryModes = !IsActive(operation.Status) ? GetRetryModes(operation) : [], + UpdateRefusedByPublisher = + operation is PackageOperation packageOperation + && PackageOperation.CanIgnoreUpdatesAfterFailure(packageOperation), Package = GetOperationPackage(operation), ManagerName = GetManagerName(operation), SourceName = GetSourceName(operation), diff --git a/src/UniGetUI.PackageEngine.Interfaces/ManagerHelpers/IPackageOperationHelper.cs b/src/UniGetUI.PackageEngine.Interfaces/ManagerHelpers/IPackageOperationHelper.cs index c8e570abf8..c09a115be4 100644 --- a/src/UniGetUI.PackageEngine.Interfaces/ManagerHelpers/IPackageOperationHelper.cs +++ b/src/UniGetUI.PackageEngine.Interfaces/ManagerHelpers/IPackageOperationHelper.cs @@ -71,5 +71,7 @@ OperationType operation ); public string? GetReinstallRefusal(IPackage package, InstallOptions options); + + public bool UpdateWasRefusedByPublisher(IReadOnlyList processOutput, int returnCode); } } diff --git a/src/UniGetUI.PackageEngine.Managers.WinGet/ClientHelpers/WinGetCliHelper.cs b/src/UniGetUI.PackageEngine.Managers.WinGet/ClientHelpers/WinGetCliHelper.cs index b7a77bbeb8..9b92a7ea6d 100644 --- a/src/UniGetUI.PackageEngine.Managers.WinGet/ClientHelpers/WinGetCliHelper.cs +++ b/src/UniGetUI.PackageEngine.Managers.WinGet/ClientHelpers/WinGetCliHelper.cs @@ -160,17 +160,17 @@ WinGetTable table in WinGetTableLayout.ReadTables( InstalledVersionIsUnverified = versionUnknown, }; // Skip one-shot suppression for unknown versions so the restored mark isn't cleared. - if ( - versionUnknown - || !WinGetPkgOperationHelper.ConsumeAlreadyUpgradedSuppression(package) - ) + bool suppressed = versionUnknown + ? WinGetPkgOperationHelper.IsStuckUpgradeLoop(package) + : WinGetPkgOperationHelper.ConsumeAlreadyUpgradedSuppression(package); + if (!suppressed) { packages.Add(package); } else { Logger.Warn( - $"WinGet package {package.Id} not being shown as an updated as this version has already been marked as installed" + $"WinGet package {package.Id} not being shown as an update to {package.NewVersionString}, since it is suppressed" ); } } diff --git a/src/UniGetUI.PackageEngine.Managers.WinGet/Helpers/WinGetPkgOperationHelper.cs b/src/UniGetUI.PackageEngine.Managers.WinGet/Helpers/WinGetPkgOperationHelper.cs index 6c764de96e..7d2067e91e 100644 --- a/src/UniGetUI.PackageEngine.Managers.WinGet/Helpers/WinGetPkgOperationHelper.cs +++ b/src/UniGetUI.PackageEngine.Managers.WinGet/Helpers/WinGetPkgOperationHelper.cs @@ -660,6 +660,19 @@ operation is OperationType.Uninstall return OperationVeredict.Failure; } + if (ReportedUpdateNotSupported(returnCode)) + { + if (operation is OperationType.Update) + { + Logger.Warn( + $"WinGet refuses to update {package.Id}: its manifest says it must be updated another way; " + + $"hiding the update to {package.NewVersionString} until a newer version is available" + ); + SuppressPhantomUpgrade(package); + } + return OperationVeredict.Failure; + } + if (ReportedUpdateNotApplicable(processOutput, returnCode)) { // The update is not applicable to the platform // The scope/architecture we forced may exclude the only installer the package ships @@ -941,6 +954,26 @@ internal static bool ReportedDifferentInstallTechnology(IEnumerable proc ) ); + internal static bool ReportedUpdateNotSupported(int returnCode) => + (uint)returnCode is 0x8A150114; + + public override bool UpdateWasRefusedByPublisher(IReadOnlyList processOutput, int returnCode) => + ReportedUpdateNotSupported(returnCode); + + public override string? GetFailureExplanation( + IPackage package, + OperationType operation, + IReadOnlyList processOutput, + int returnCode, + InstallOptions? options = null + ) => + operation is OperationType.Update && ReportedUpdateNotSupported(returnCode) + ? CoreTools.Translate( + "WinGet cannot update {package}. Its publisher requires updating it another way, for example from within the app itself", + new Dictionary { { "package", package.Name } } + ) + : null; + internal static bool ReportedApplicationCurrentlyRunning(int returnCode) => (uint)returnCode is 0x8A150101 or 0x8A150103 or 0x8A150111; diff --git a/src/UniGetUI.PackageEngine.Operations/PackageOperations.cs b/src/UniGetUI.PackageEngine.Operations/PackageOperations.cs index 83a09fc668..ec2793241b 100644 --- a/src/UniGetUI.PackageEngine.Operations/PackageOperations.cs +++ b/src/UniGetUI.PackageEngine.Operations/PackageOperations.cs @@ -104,6 +104,7 @@ internal void AdoptReinstallStepFailure() } internal bool IsReinstallStep { get; init; } public bool FailedBecauseApplicationRunning { get; private set; } + public bool FailedBecauseUpdateNotSupported { get; private set; } public Task SuccessHandled { get; private set; } = Task.CompletedTask; private IReadOnlyList _closeRunningAppProcessNames = []; private readonly List _brokerKillBeforeOperationAdded = []; @@ -1225,6 +1226,7 @@ List Output ); FailedBecauseApplicationRunning = false; + FailedBecauseUpdateNotSupported = false; Metadata.FailureTitle = _genericFailureTitle; Metadata.FailureMessage = _genericFailureMessage; if (veredict is OperationVeredict.Failure) @@ -1241,7 +1243,11 @@ List Output ) Metadata.FailureMessage = explanation; if (CommandRole is OperationType.Update) + { ExplainNotApplicableUpdate(Output, ReturnCode); + FailedBecauseUpdateNotSupported = + Package.Manager.OperationHelper.UpdateWasRefusedByPublisher(Output, ReturnCode); + } ExplainInstallerHashMismatch(ReturnCode); ExplainApplicationCurrentlyRunning(Output, ReturnCode); ExplainFileInUse(Output); @@ -1465,6 +1471,12 @@ private void ExplainNotApplicableUpdate(List output, int returnCode) #endif } + public static bool CanIgnoreUpdatesAfterFailure(PackageOperation operation) => + operation.FailedBecauseUpdateNotSupported; + + public static bool IsWorthRetryingInBulk(AbstractOperation operation) => + operation is not PackageOperation { FailedBecauseUpdateNotSupported: true }; + private void ExplainInstallerHashMismatch(int returnCode) { #if WINDOWS diff --git a/src/UniGetUI.PackageEngine.PackageLoader/UpgradablePackagesLoader.cs b/src/UniGetUI.PackageEngine.PackageLoader/UpgradablePackagesLoader.cs index f25cf45bdd..5686cb3c2a 100644 --- a/src/UniGetUI.PackageEngine.PackageLoader/UpgradablePackagesLoader.cs +++ b/src/UniGetUI.PackageEngine.PackageLoader/UpgradablePackagesLoader.cs @@ -30,6 +30,16 @@ public UpgradablePackagesLoader(IReadOnlyList managers) Instance = this; } + public async Task IgnoreUpdatesAsync(IPackage package, string version = "*") + { + await package.AddToIgnoredUpdatesAsync(version); + if (GetEquivalentPackage(package) is not { } upgradable) + return; + + IgnoredPackages[upgradable.Id] = upgradable; + Remove(upgradable); + } + protected override async Task IsPackageValid(IPackage package) { if (package.VersionString == package.NewVersionString) diff --git a/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Classes/NullPackageManager.cs b/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Classes/NullPackageManager.cs index df2b50e6f2..29895382f2 100644 --- a/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Classes/NullPackageManager.cs +++ b/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Classes/NullPackageManager.cs @@ -226,5 +226,8 @@ OperationType operation ) => null; public string? GetReinstallRefusal(IPackage package, InstallOptions options) => null; + + public bool UpdateWasRefusedByPublisher(IReadOnlyList processOutput, int returnCode) => + false; } } diff --git a/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Helpers/BasePkgOperationHelper.cs b/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Helpers/BasePkgOperationHelper.cs index 08342392c0..cf13d72555 100644 --- a/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Helpers/BasePkgOperationHelper.cs +++ b/src/UniGetUI.PackageEngine.PackageManagerClasses/Manager/Helpers/BasePkgOperationHelper.cs @@ -180,4 +180,7 @@ OperationType operation ) => null; public virtual string? GetReinstallRefusal(IPackage package, InstallOptions options) => null; + + public virtual bool UpdateWasRefusedByPublisher(IReadOnlyList processOutput, int returnCode) => + false; } diff --git a/src/UniGetUI.PackageEngine.Tests/UpgradablePackagesLoaderTests.cs b/src/UniGetUI.PackageEngine.Tests/UpgradablePackagesLoaderTests.cs index 946eebef3a..0057019cf0 100644 --- a/src/UniGetUI.PackageEngine.Tests/UpgradablePackagesLoaderTests.cs +++ b/src/UniGetUI.PackageEngine.Tests/UpgradablePackagesLoaderTests.cs @@ -198,6 +198,53 @@ await installedLoader.AddForeign( Assert.False(await loader.EvaluatePackageAsync(supersededPackage)); } + [Fact] + public async Task IgnoreUpdatesAsync_RemovesTheListedUpdateWhenGivenAnotherInstanceOfIt() + { + var manager = new PackageManagerBuilder().Build(); + _ = new InstalledPackagesLoader([manager]); + _ = new DiscoverablePackagesLoader([manager]); + var loader = new TestUpgradablePackagesLoader([manager]); + var listed = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.Tool") + .WithVersion("1.0.0") + .WithNewVersion("2.0.0") + .Build(); + var installed = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.Tool") + .WithVersion("1.0.0") + .Build(); + await loader.AddForeign(listed); + + await loader.IgnoreUpdatesAsync(installed); + + Assert.False(loader.Contains(listed)); + Assert.Same(listed, loader.IgnoredPackages["Contoso.Tool"]); + Assert.True(await listed.HasUpdatesIgnoredAsync()); + } + + [Fact] + public async Task IgnoreUpdatesAsync_RecordsTheRuleEvenWhenNoUpdateIsListed() + { + var manager = new PackageManagerBuilder().Build(); + _ = new InstalledPackagesLoader([manager]); + _ = new DiscoverablePackagesLoader([manager]); + var loader = new TestUpgradablePackagesLoader([manager]); + var installed = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.Tool") + .WithVersion("1.0.0") + .Build(); + + await loader.IgnoreUpdatesAsync(installed, "2.0.0"); + + Assert.Empty(loader.IgnoredPackages); + Assert.True(await installed.HasUpdatesIgnoredAsync("2.0.0")); + Assert.False(await installed.HasUpdatesIgnoredAsync("3.0.0")); + } + // Regression test for issue #5293: the installed version carried a Homebrew build revision // ("18.4_1"), which the version parser read as 18.41. That compared as greater than the // available 18.6, so the loader discarded the update and it never reached the UI. diff --git a/src/UniGetUI.PackageEngine.Tests/WinGetCliParsingTests.cs b/src/UniGetUI.PackageEngine.Tests/WinGetCliParsingTests.cs index cb69d36422..e60161391c 100644 --- a/src/UniGetUI.PackageEngine.Tests/WinGetCliParsingTests.cs +++ b/src/UniGetUI.PackageEngine.Tests/WinGetCliParsingTests.cs @@ -313,6 +313,35 @@ Xbox Identity Provider MSIX\Microsoft.XboxIdentityProvider_12.130.16001.0_arm64_ Assert.Same(manager.MicrosoftStoreSource, packages[3].Source); } + [Fact] + public void ParseAvailableUpdatesKeepsARefusedUpdateHiddenWhenTheInstalledVersionIsUnknown() + { + var manager = new WinGet(); + var refused = new PackageBuilder() + .WithManager(manager) + .WithId("Fabrikam.Refused") + .WithVersion("Unknown") + .WithNewVersion("2.0.0") + .Build(); + string[] listing = Lines( + """ + Name Id Version Available Source + -------------------------------------------------- + Refused Fabrikam.Refused Unknown 2.0.0 winget + Other Fabrikam.Other Unknown 2.0.0 winget + """ + ); + + Assert.Equal(2, WinGetCliHelper.ParseAvailableUpdates(manager, listing).Count); + + manager.OperationHelper.GetResult(refused, OperationType.Update, [], unchecked((int)0x8A150114)); + + IReadOnlyList relisted = WinGetCliHelper.ParseAvailableUpdates(manager, listing); + Assert.Single(relisted); + Assert.Equal("Fabrikam.Other", relisted[0].Id); + Assert.Single(WinGetCliHelper.ParseAvailableUpdates(manager, listing)); + } + [Fact] public void ParseInstalledPackagesFlagsRowsWhoseVersionWinGetCouldNotRead() { diff --git a/src/UniGetUI.PackageEngine.Tests/WinGetManagerTests.cs b/src/UniGetUI.PackageEngine.Tests/WinGetManagerTests.cs index 2ca413ec29..877ec18620 100644 --- a/src/UniGetUI.PackageEngine.Tests/WinGetManagerTests.cs +++ b/src/UniGetUI.PackageEngine.Tests/WinGetManagerTests.cs @@ -4365,6 +4365,112 @@ public async Task WinGetFailureWithBareExitCode26KeepsTheDefaultMessage() Assert.Equal(defaultMessage, operation.Metadata.FailureMessage); Assert.False(operation.FailedBecauseApplicationRunning); Assert.False(PackageOperation.CanRetryClosingRunningApp(operation)); + Assert.False(PackageOperation.CanIgnoreUpdatesAfterFailure(operation)); + } + + [Fact] + public void WinGetRecognisesOnlyTheUpgradeNotSupportedCode() + { + Assert.True(WinGetPkgOperationHelper.ReportedUpdateNotSupported(unchecked((int)0x8A150114))); + Assert.False(WinGetPkgOperationHelper.ReportedUpdateNotSupported(unchecked((int)0x8A150014))); + Assert.False(WinGetPkgOperationHelper.ReportedUpdateNotSupported(0)); + } + + [Fact] + public async Task WinGetUpdateNotSupportedExplainsTheFailureAndOffersToIgnoreUpdates() + { + var manager = new WinGet(); + var package = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.SelfUpdatingTool") + .WithName("MSYS2") + .WithVersion("20260611") + .WithNewVersion("20260927") + .Build(); + using var operation = new VeredictProbingUpdateOperation(package, new InstallOptions()); + string defaultMessage = operation.Metadata.FailureMessage; + + var veredict = await operation.ProbeProcessVeredict( + unchecked((int)0x8A150114), + [ + "Found MSYS2 [Contoso.SelfUpdatingTool] Version 20260927", + "The package cannot be upgraded using winget. Please use the method provided by the publisher for upgrading this package.", + ] + ); + + OperationAssert.HasVeredict(veredict, OperationVeredict.Failure); + Assert.NotEqual(defaultMessage, operation.Metadata.FailureMessage); + Assert.Contains("MSYS2", operation.Metadata.FailureMessage); + Assert.False(operation.Metadata.FailureMessage.EndsWith('.')); + Assert.True(operation.FailedBecauseUpdateNotSupported); + Assert.True(PackageOperation.CanIgnoreUpdatesAfterFailure(operation)); + Assert.False(PackageOperation.IsWorthRetryingInBulk(operation)); + Assert.False(operation.FailedBecauseApplicationRunning); + Assert.True(WinGetPkgOperationHelper.IsStuckUpgradeLoop(package)); + + veredict = await operation.ProbeProcessVeredict(26, []); + + OperationAssert.HasVeredict(veredict, OperationVeredict.Failure); + Assert.Equal(defaultMessage, operation.Metadata.FailureMessage); + Assert.False(PackageOperation.CanIgnoreUpdatesAfterFailure(operation)); + Assert.True(PackageOperation.IsWorthRetryingInBulk(operation)); + } + + [Fact] + public void WinGetHidesARefusedUpdateOnlyUntilANewerVersionIsOffered() + { + var manager = new WinGet(); + var refused = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.RefusedUpdate") + .WithVersion("20260611") + .WithNewVersion("20260927") + .Build(); + var newer = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.RefusedUpdate") + .WithVersion("20260611") + .WithNewVersion("20261025") + .Build(); + Assert.False(WinGetPkgOperationHelper.IsStuckUpgradeLoop(refused)); + + var veredict = manager.OperationHelper.GetResult( + refused, + OperationType.Update, + [], + unchecked((int)0x8A150114) + ); + + OperationAssert.HasVeredict(veredict, OperationVeredict.Failure); + Assert.True(WinGetPkgOperationHelper.IsStuckUpgradeLoop(refused)); + Assert.False(WinGetPkgOperationHelper.IsStuckUpgradeLoop(newer)); + } + + [Fact] + public void WinGetDoesNotHideAnythingWhenAnInstallIsRefused() + { + var manager = new WinGet(); + var package = new PackageBuilder() + .WithManager(manager) + .WithId("Contoso.RefusedInstall") + .WithVersion("20260611") + .WithNewVersion("20260927") + .Build(); + + var veredict = manager.OperationHelper.GetResult( + package, + OperationType.Install, + [], + unchecked((int)0x8A150114) + ); + + OperationAssert.HasVeredict(veredict, OperationVeredict.Failure); + Assert.False(WinGetPkgOperationHelper.IsStuckUpgradeLoop(package)); + Assert.Null( + manager.OperationHelper.GetFailureExplanation(package, OperationType.Install, [], unchecked((int)0x8A150114)) + ); + Assert.True(manager.OperationHelper.UpdateWasRefusedByPublisher([], unchecked((int)0x8A150114))); + Assert.False(manager.OperationHelper.UpdateWasRefusedByPublisher([], unchecked((int)0x8A150014))); } [Fact] diff --git a/src/UniGetUI.Tui/Infrastructure/TuiOperationRegistry.cs b/src/UniGetUI.Tui/Infrastructure/TuiOperationRegistry.cs index cb2f7de654..c9963b798e 100644 --- a/src/UniGetUI.Tui/Infrastructure/TuiOperationRegistry.cs +++ b/src/UniGetUI.Tui/Infrastructure/TuiOperationRegistry.cs @@ -3,6 +3,7 @@ using UniGetUI.Core.SettingsEngine; using UniGetUI.Core.Tools; using UniGetUI.PackageEngine.Enums; +using UniGetUI.PackageEngine.Operations; using UniGetUI.PackageEngine.Operations.History; using UniGetUI.PackageOperations; @@ -119,7 +120,7 @@ public static void ClearFinished() => RemoveWhere(o => o.Status is OperationStat public static void RetryFailed() { - foreach (var op in Snapshot().Where(o => o.Status is OperationStatus.Failed)) + foreach (var op in Snapshot().Where(o => o.Status is OperationStatus.Failed && PackageOperation.IsWorthRetryingInBulk(o))) op.Retry(AbstractOperation.RetryMode.Retry); } diff --git a/src/UniGetUI.Tui/Infrastructure/TuiPackageActions.cs b/src/UniGetUI.Tui/Infrastructure/TuiPackageActions.cs index 61a6e3414d..64958cdbec 100644 --- a/src/UniGetUI.Tui/Infrastructure/TuiPackageActions.cs +++ b/src/UniGetUI.Tui/Infrastructure/TuiPackageActions.cs @@ -170,12 +170,8 @@ public static string DefaultDownloadDirectory() // ─── Ignored updates ──────────────────────────────────────────────────── - public static async Task IgnoreUpdatesAsync(IPackage package, string version = "*") - { - await package.AddToIgnoredUpdatesAsync(version); - UpgradablePackagesLoader.Instance.IgnoredPackages[package.Id] = package; - UpgradablePackagesLoader.Instance.Remove(package); - } + public static Task IgnoreUpdatesAsync(IPackage package, string version = "*") => + UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(package, version); public static Task SkipVersionAsync(IPackage package) => IgnoreUpdatesAsync(package, package.NewVersionString); @@ -197,13 +193,7 @@ public static async Task ToggleIgnoreUpdatesAsync(IPackage package) return false; } - await package.AddToIgnoredUpdatesAsync(); - if (package.GetUpgradablePackage() is { } upgradable) - { - UpgradablePackagesLoader.Instance.IgnoredPackages[upgradable.Id] = upgradable; - UpgradablePackagesLoader.Instance.Remove(upgradable); - } - + await UpgradablePackagesLoader.Instance.IgnoreUpdatesAsync(package); return true; }