ci: bootstrap Devolutions#5311 backport

Author: martesi

.github/workflows/backport-5311-bootstrap.yml

@@ -0,0 +1,290 @@
+name: Bootstrap upstream #5311 backport
+
+on:
+  push:
+    branches:
+      - classic-test-upstream-backports-3
+
+permissions:
+  contents: write
+
+jobs:
+  apply:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+          ref: classic-test-upstream-backports-3
+
+      - name: Build clean backport commit
+        shell: bash
+        run: |
+          set -euo pipefail
+          base="$(git rev-parse "$GITHUB_SHA^")"
+          git reset --hard "$base"
+
+          python3 - <<'PY'
+          from pathlib import Path
+
+          package_path = Path('src/UniGetUI.PackageEngine.PackageManagerClasses/Packages/Package.cs')
+          package = package_path.read_text()
+
+          old = '        private static readonly ConcurrentDictionary<int, Uri?> _cachedIconPaths = new();\n'
+          new = '''        private static readonly ConcurrentDictionary<long, Uri> _cachedIconPaths = new();
+        private static readonly ConcurrentDictionary<long, long> _failedIconLookups = new();
+        private static readonly TimeSpan _iconLookupRetryInterval = TimeSpan.FromMinutes(5);
+
+        public static TimeSpan? TEST_IconLookupRetryIntervalOverride { private get; set; }
+
+        private static TimeSpan IconLookupRetryInterval =>
+            TEST_IconLookupRetryIntervalOverride ?? _iconLookupRetryInterval;
+'''
+          assert old in package
+          package = package.replace(old, new, 1)
+
+          old = '''        public virtual Uri? GetIconUrlIfAny()
+        {
+            if (_cachedIconPaths.TryGetValue(this.GetHashCode(), out Uri? path))
+            {
+                return path;
+            }
+            var CachedIcon = LoadIconUrlIfAny();
+            _cachedIconPaths.TryAdd(this.GetHashCode(), CachedIcon);
+            return CachedIcon;
+        }
+'''
+          new = '''        public virtual Uri? GetIconUrlIfAny()
+        {
+            long cacheKey = _versionedHash;
+            if (_cachedIconPaths.TryGetValue(cacheKey, out Uri? path))
+            {
+                return path;
+            }
+
+            if (
+                _failedIconLookups.TryGetValue(cacheKey, out long failedAt)
+                && Environment.TickCount64 - failedAt
+                    < (long)IconLookupRetryInterval.TotalMilliseconds
+            )
+            {
+                return null;
+            }
+
+            var CachedIcon = LoadIconUrlIfAny();
+            if (CachedIcon is null)
+            {
+                _failedIconLookups[cacheKey] = Environment.TickCount64;
+                return null;
+            }
+
+            _failedIconLookups.TryRemove(cacheKey, out _);
+            _cachedIconPaths[cacheKey] = CachedIcon;
+            return CachedIcon;
+        }
+'''
+          assert old in package
+          package = package.replace(old, new, 1)
+
+          old = '''        public static void ResetIconCache()
+        {
+            _cachedIconPaths.Clear();
+        }
+'''
+          new = '''        public static void ResetIconCache()
+        {
+            _cachedIconPaths.Clear();
+            _failedIconLookups.Clear();
+        }
+'''
+          assert old in package
+          package = package.replace(old, new, 1)
+          package_path.write_text(package)
+
+          icon_path = Path('src/UniGetUI.Core.IconStore/IconCacheEngine.cs')
+          icon = icon_path.read_text()
+          assert icon.count('image/image/x-icon') == 2
+          icon = icon.replace('image/image/x-icon', 'image/x-icon')
+          icon_path.write_text(icon)
+
+          test_path = Path('src/UniGetUI.PackageEngine.Tests/PackageIconLookupTests.cs')
+          test_path.write_text('''using UniGetUI.Core.Data;
+using UniGetUI.Core.IconEngine;
+using UniGetUI.Core.SettingsEngine;
+using UniGetUI.Core.SettingsEngine.SecureSettings;
+using UniGetUI.PackageEngine.Interfaces;
+using UniGetUI.PackageEngine.PackageClasses;
+using UniGetUI.PackageEngine.Tests.Infrastructure.Builders;
+
+namespace UniGetUI.PackageEngine.Tests;
+
+public sealed class PackageIconLookupTests : IDisposable
+{
+    private readonly string _testRoot;
+
+    public PackageIconLookupTests()
+    {
+        _testRoot = Path.Combine(
+            Path.GetTempPath(),
+            nameof(PackageIconLookupTests),
+            Guid.NewGuid().ToString("N")
+        );
+        CoreData.TEST_DataDirectoryOverride = Path.Combine(_testRoot, "Data");
+        SecureSettings.TEST_SecureSettingsRootOverride = Path.Combine(_testRoot, "SecureSettings");
+        Directory.CreateDirectory(CoreData.UniGetUIUserConfigurationDirectory);
+        Settings.ResetSettings();
+        Package.ResetIconCache();
+    }
+
+    public void Dispose()
+    {
+        Package.TEST_IconLookupRetryIntervalOverride = null;
+        Package.ResetIconCache();
+        Settings.ResetSettings();
+        CoreData.TEST_DataDirectoryOverride = null;
+        SecureSettings.TEST_SecureSettingsRootOverride = null;
+        if (Directory.Exists(_testRoot))
+            Directory.Delete(_testRoot, recursive: true);
+    }
+
+    [Fact]
+    public void GetIconUrlIfAny_DoesNotRetryFailedLookupWithinRetryInterval()
+    {
+        int lookups = 0;
+        var package = BuildPackage(
+            "Contoso.WithinInterval",
+            _ =>
+            {
+                lookups++;
+                return null;
+            }
+        );
+
+        Assert.Null(package.GetIconUrlIfAny());
+        Assert.Null(package.GetIconUrlIfAny());
+
+        Assert.Equal(1, lookups);
+    }
+
+    [Fact]
+    public void GetIconUrlIfAny_RetriesFailedLookupAfterRetryInterval()
+    {
+        Package.TEST_IconLookupRetryIntervalOverride = TimeSpan.Zero;
+        string iconPath = CreateIconFile();
+
+        int lookups = 0;
+        var package = BuildPackage(
+            "Contoso.AfterInterval",
+            _ =>
+            {
+                lookups++;
+                return lookups == 1 ? null : new CacheableIcon(iconPath);
+            }
+        );
+
+        Assert.Null(package.GetIconUrlIfAny());
+        Uri? retried = package.GetIconUrlIfAny();
+
+        Assert.Equal(2, lookups);
+        Assert.NotNull(retried);
+        Assert.True(retried.IsFile);
+        Assert.Equal(iconPath, retried.LocalPath);
+    }
+
+    [Fact]
+    public void GetIconUrlIfAny_DoesNotResolveResolvedIconAgain()
+    {
+        Package.TEST_IconLookupRetryIntervalOverride = TimeSpan.Zero;
+        string iconPath = CreateIconFile();
+
+        int lookups = 0;
+        var package = BuildPackage(
+            "Contoso.AlreadyResolved",
+            _ =>
+            {
+                lookups++;
+                return new CacheableIcon(iconPath);
+            }
+        );
+
+        Uri? first = package.GetIconUrlIfAny();
+        Uri? second = package.GetIconUrlIfAny();
+
+        Assert.Equal(1, lookups);
+        Assert.Equal(first, second);
+    }
+
+    [Fact]
+    public void ResetIconCache_AllowsFailedLookupToBeRetriedImmediately()
+    {
+        int lookups = 0;
+        var package = BuildPackage(
+            "Contoso.AfterReset",
+            _ =>
+            {
+                lookups++;
+                return null;
+            }
+        );
+
+        Assert.Null(package.GetIconUrlIfAny());
+        Package.ResetIconCache();
+        Assert.Null(package.GetIconUrlIfAny());
+
+        Assert.Equal(2, lookups);
+    }
+
+    private string CreateIconFile()
+    {
+        Directory.CreateDirectory(_testRoot);
+        string iconPath = Path.Combine(_testRoot, "icon.png");
+        File.WriteAllBytes(iconPath, [0x89, 0x50, 0x4E, 0x47]);
+        return iconPath;
+    }
+
+    private static Package BuildPackage(string id, Func<IPackage, CacheableIcon?> iconFactory)
+    {
+        var manager = new PackageManagerBuilder()
+            .ConfigureCapabilities(capabilities =>
+            {
+                capabilities.SupportsCustomPackageIcons = true;
+                return capabilities;
+            })
+            .ConfigureDetails(details => details.IconFactory = iconFactory)
+            .Build();
+
+        return new PackageBuilder().WithId(id).WithManager(manager).Build();
+    }
+}
+''')
+
+          ledger_path = Path('maintenance/backports.yml')
+          ledger = ledger_path.read_text()
+          marker = 'backports:\n'
+          assert marker in ledger
+          entry = '''backports:
+  - commit: 460178a3e99361946e570025a3a8e0c8b0257336
+    upstream_pr: 5311
+    status: applied-semantic
+    class: backend-shared-icon-cache
+    reason: Retries transient package icon lookup failures after five minutes, caches successful resolutions by full versioned hash, and fixes the x-icon MIME mapping. Avalonia bitmap-cache changes are omitted because Classic WinUI only stores icon URLs after successful lookup.
+
+'''
+          ledger = ledger.replace(marker, entry, 1)
+          ledger_path.write_text(ledger)
+          PY
+
+          git add maintenance/backports.yml \
+            src/UniGetUI.PackageEngine.PackageManagerClasses/Packages/Package.cs \
+            src/UniGetUI.Core.IconStore/IconCacheEngine.cs \
+            src/UniGetUI.PackageEngine.Tests/PackageIconLookupTests.cs
+
+          test "$(git diff --cached --name-only | wc -l)" -eq 4
+          ! git diff --cached --name-only | grep -q '^src/UniGetUI.Avalonia/'
+
+          git config user.name 'github-actions[bot]'
+          git config user.email '41898282+github-actions[bot]@users.noreply.github.com'
+          git commit -m 'backport: retry transient package icon failures' \
+            -m 'Upstream-Commit: 460178a3e99361946e570025a3a8e0c8b0257336' \
+            -m 'Upstream-PR: Devolutions/UniGetUI#5311'
+          git push --force-with-lease origin HEAD:classic-test-upstream-backports-3