fix: Copilot 审查后修复 — 备份排序改用创建时间、修正注释、补全测试断言 (#503)

* fix: address Copilot review feedback on backup PR (#502)

1. GetLatestBackup / CleanDirectories: sort by directory creation time
   instead of name. Legacy 'app-{version}' names are not reliably
   lexicographically sortable (e.g. app-10.0.0 vs app-2.0.0), and mixing
   .backups/ paths with installPath/ dirs breaks path-string ordering.
   Fallback to name tiebreaker for deterministic results.

2. ClientStrategy XML doc: corrected to .backups/backup-{yyyyMMddHHmmss}
   format (was stale __backups/backup_{...}).

3. CleanBackup_KeepsOnlyRecentVersions test: added missing assertion to
   verify legacy app-* directory retention behavior.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

* fix: GetLatestBackup test now creates dirs in creation-time order

The test expected the alphabetically-last directory, but GetLatestBackup
now sorts by CreationTime. The newest (last-created) directory must
match the expected result. Added Thread.Sleep(10) between creates
to ensure distinct timestamps on fast filesystems (e.g. Linux CI).

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.8 <noreply@anthropic.com>

Author: JusterZhu

src/c#/GeneralUpdate.Core/FileSystem/StorageManager.cs

@@ -225,41 +225,44 @@ public static string GetTempDirectory(string name)
         /// <param name="installPath">The application installation root directory.</param>
         /// <returns>The full path of the most recent backup directory, or <c>null</c> if none exists.</returns>
         /// <remarks>
-        /// Directories are sorted by name in descending order. Since both "backup-{yyyyMMddHHmmss}"
-        /// and "app-{version}" formats are lexicographically sortable, this works for both.
-        /// Search patterns are derived from <see cref="BlackDefaults.DefaultDirectories"/> by
-        /// appending "*" to each entry — e.g. "backup-" becomes "backup-*".
+        /// Sorts candidates by directory creation time descending (most recent first), with
+        /// a name-based tie-breaker for deterministic results. Unlike lexicographic name
+        /// sorting, this correctly handles mixed paths (e.g. .backups/ vs installPath/)
+        /// and legacy version-format names ("app-10.0.0" vs "app-2.0.0").
         /// </remarks>
         public static string? GetLatestBackup(string installPath)
         {
             if (!Directory.Exists(installPath)) return null;
 
-            var allBackups = new List<string>();
+            var allBackups = new List<DirectoryInfo>();
 
             // Scan BackupRootDirectory subdirectory (new-format backup container)
             var backupRoot = Path.Combine(installPath, BackupRootDirectory);
             if (Directory.Exists(backupRoot))
             {
-                allBackups.AddRange(Directory.GetDirectories(backupRoot, "*", SearchOption.TopDirectoryOnly));
+                allBackups.AddRange(new DirectoryInfo(backupRoot)
+                    .GetDirectories("*", SearchOption.TopDirectoryOnly));
             }
 
             // Scan installPath directly for backup dirs matching patterns from defaults
-            allBackups.AddRange(GetBackupDirectories(installPath));
+            allBackups.AddRange(GetBackupDirectoryInfos(installPath));
 
             return allBackups
-                .OrderByDescending(d => d)
-                .FirstOrDefault();
+                .OrderByDescending(d => d.CreationTime)
+                .ThenByDescending(d => d.Name)
+                .FirstOrDefault()?.FullName;
         }
 
         /// <summary>
         /// Enumerates all backup directories in the given path using patterns derived
         /// from <see cref="BackupNamePrefixes"/> (both new and legacy formats).
         /// </summary>
-        private static IEnumerable<string> GetBackupDirectories(string path)
+        private static IEnumerable<DirectoryInfo> GetBackupDirectoryInfos(string path)
         {
+            var dirInfo = new DirectoryInfo(path);
             foreach (var prefix in BackupNamePrefixes)
             {
-                foreach (var dir in Directory.GetDirectories(path, prefix + "*", SearchOption.TopDirectoryOnly))
+                foreach (var dir in dirInfo.GetDirectories(prefix + "*", SearchOption.TopDirectoryOnly))
                 {
                     yield return dir;
                 }
@@ -637,9 +640,10 @@ private static IEnumerable<string> GetBackupSearchPatterns()
         /// </summary>
         private static void CleanDirectories(string rootPath, int keepVersions, string searchPattern = "*")
         {
-            var dirs = Directory.GetDirectories(rootPath, searchPattern, SearchOption.TopDirectoryOnly)
-                .Select(d => new DirectoryInfo(d))
-                .OrderByDescending(d => d.Name)
+            var dirs = new DirectoryInfo(rootPath)
+                .GetDirectories(searchPattern, SearchOption.TopDirectoryOnly)
+                .OrderByDescending(d => d.CreationTime)
+                .ThenByDescending(d => d.Name)
                 .Skip(keepVersions);
 
             foreach (var dir in dirs)

src/c#/GeneralUpdate.Core/Strategy/ClientStrategy.cs

@@ -854,7 +854,7 @@ private void InitBlackPolicy()
     /// </summary>
     /// <remarks>
     /// The backup operation is performed via <c>StorageManager.Backup</c>, excluding directories configured in the blacklist.
-    /// The backup directory path format is: {InstallPath}/__backups/backup_{yyyyMMddHHmmss}.
+    /// The backup directory path format is: {InstallPath}/.backups/backup-{yyyyMMddHHmmss}.
     /// This step can be skipped by setting <c>UpdateContext.BackupEnabled</c> to <c>false</c>.
     /// After a successful backup, old backups are cleaned up, retaining only the most recent 3.
     /// </remarks>

tests/CoreTest/FileSystem/BackupRestoreTests.cs

@@ -1,6 +1,7 @@
 using System;
 using System.IO;
 using System.Linq;
+using System.Threading;
 using GeneralUpdate.Core.FileSystem;
 using Xunit;
 
@@ -71,9 +72,10 @@ public void CleanBackup_KeepsOnlyRecentVersions()
             Assert.Contains("backup-20260606000004", names[1]);
             Assert.Contains("backup-20260606000005", names[2]);
 
-            // Legacy app-* should also be cleaned (keeps top 3, but there's only 1 legacy,
-            // and since we're using CleanBackup with keepVersions=3, the one legacy dir
-            // at installPath level would be kept unless there are 3+ newer app-* dirs)
+            // Legacy app-* — single directory is retained (only 1 total, keepVersions=3)
+            var legacyRemaining = Directory.GetDirectories(installPath, "app-*");
+            Assert.Single(legacyRemaining);
+            Assert.Equal("app-0.0.1", Path.GetFileName(legacyRemaining[0]));
         }
         finally
         {
@@ -148,17 +150,19 @@ public void GetLatestBackup_ReturnsMostRecent()
         {
             Directory.CreateDirectory(installPath);
 
-            // Create backup dirs with different timestamps
+            // Create backup dirs in creation-time order: oldest first, newest last
             var dir1 = Path.Combine(installPath, "backup-20260601000000");
-            var dir2 = Path.Combine(installPath, "backup-20260606235200"); // This is the latest
-            var dir3 = Path.Combine(installPath, "backup-20260603000000");
+            var dir2 = Path.Combine(installPath, "backup-20260603000000");
+            var dir3 = Path.Combine(installPath, "backup-20260606235200"); // Created last = most recent
             Directory.CreateDirectory(dir1);
+            Thread.Sleep(10); // Ensure distinct creation time on fast filesystems
             Directory.CreateDirectory(dir2);
+            Thread.Sleep(10);
             Directory.CreateDirectory(dir3);
 
             var latest = StorageManager.GetLatestBackup(installPath);
             Assert.NotNull(latest);
-            Assert.Equal(dir2, latest); // backup-20260606235200 is alphabetically last
+            Assert.Equal(dir3, latest); // Most recently created
         }
         finally
         {