changed.对启动器重构的尝试

LanMountainDesktop.Tests/LauncherArchitectureTests.cs

@@ -1,23 +1,22 @@
-using System.Reflection;
 using Xunit;
 
 namespace LanMountainDesktop.Tests;
 
 public sealed class LauncherArchitectureTests
 {
-    private static readonly string LauncherAssemblyName = "LanMountainDesktop.Launcher";
-
     [Fact]
-    public void Deployment_Update_Startup_Infrastructure_DoNotReferenceAvalonia()
+    public void CoreLauncherFolders_DoNotUseAvaloniaNamespaces()
     {
         var forbidden = new[] { "Deployment", "Update", "Startup", "Infrastructure" };
-        foreach (var nsSuffix in forbidden)
+        foreach (var folder in forbidden.Select(folder => Path.Combine(LauncherProjectRoot, folder)))
         {
-            var types = GetLauncherTypes($"LanMountainDesktop.Launcher.{nsSuffix}");
-            var assembly = types.First().Assembly;
-            Assert.DoesNotContain(
-                assembly.GetReferencedAssemblies(),
-                a => string.Equals(a.Name, "Avalonia", StringComparison.OrdinalIgnoreCase));
+            var offenders = Directory
+                .EnumerateFiles(folder, "*.cs", SearchOption.AllDirectories)
+                .Where(file => File.ReadAllText(file).Contains("using Avalonia", StringComparison.Ordinal))
+                .Select(RelativeToRepo)
+                .ToArray();
+
+            Assert.Empty(offenders);
         }
     }
 
@@ -29,13 +28,59 @@ public sealed class LauncherArchitectureTests
         Assert.Null(coordinator);
     }
 
-    private static IEnumerable<Type> GetLauncherTypes(string namespacePrefix)
+    [Fact]
+    public void CliAndShellEntryHandlers_DoNotDependOnConcreteUpdateEngineFacade()
     {
-        var assembly = AppDomain.CurrentDomain.GetAssemblies()
-            .FirstOrDefault(a => string.Equals(a.GetName().Name, LauncherAssemblyName, StringComparison.OrdinalIgnoreCase))
-            ?? throw new InvalidOperationException("Launcher assembly not loaded.");
+        var guardedFiles = new[]
+        {
+            Path.Combine(LauncherProjectRoot, "Infrastructure", "Commands.cs"),
+            Path.Combine(LauncherProjectRoot, "Shell", "ApplyUpdateGuiFlow.cs")
+        }.Concat(Directory.EnumerateFiles(
+            Path.Combine(LauncherProjectRoot, "Shell", "EntryHandlers"),
+            "*.cs",
+            SearchOption.AllDirectories));
 
-        return assembly.GetTypes()
-            .Where(t => t.Namespace is not null && t.Namespace.StartsWith(namespacePrefix, StringComparison.Ordinal));
+        var offenders = guardedFiles
+            .Where(file => File.ReadAllText(file).Contains("UpdateEngineFacade", StringComparison.Ordinal))
+            .Select(RelativeToRepo)
+            .ToArray();
+
+        Assert.Empty(offenders);
     }
+
+    [Fact]
+    public void LauncherFacadeAndCompositionRootStayThin()
+    {
+        AssertFileLineCountAtMost(Path.Combine(LauncherProjectRoot, "Update", "UpdateEngineFacade.cs"), 140);
+        AssertFileLineCountAtMost(Path.Combine(LauncherProjectRoot, "Shell", "LauncherCompositionRoot.cs"), 80);
+    }
+
+    private static string LauncherProjectRoot => Path.Combine(RepoRoot, "LanMountainDesktop.Launcher");
+
+    private static string RepoRoot
+    {
+        get
+        {
+            var current = new DirectoryInfo(AppContext.BaseDirectory);
+            while (current is not null)
+            {
+                if (File.Exists(Path.Combine(current.FullName, "LanMountainDesktop.slnx")))
+                {
+                    return current.FullName;
+                }
+
+                current = current.Parent;
+            }
+
+            throw new InvalidOperationException("Unable to locate repository root.");
+        }
+    }
+
+    private static void AssertFileLineCountAtMost(string path, int maxLines)
+    {
+        var lineCount = File.ReadLines(path).Count();
+        Assert.True(lineCount <= maxLines, $"{RelativeToRepo(path)} has {lineCount} lines; expected <= {maxLines}.");
+    }
+
+    private static string RelativeToRepo(string path) => Path.GetRelativePath(RepoRoot, path);
 }

LanMountainDesktop.Tests/UpdateStrategyTests.cs

@@ -0,0 +1,250 @@
+using System.IO.Compression;
+using System.Security.Cryptography;
+using System.Text;
+using System.Text.Json;
+using LanMountainDesktop.Launcher;
+using LanMountainDesktop.Launcher.Models;
+using Xunit;
+
+namespace LanMountainDesktop.Tests;
+
+public sealed class PendingUpdateDetectorTests : IDisposable
+{
+    private readonly TempLauncherRoot _root = new();
+
+    [Fact]
+    public void ValidateIncomingState_WhenNoPayloadButDeploymentLockExists_ReturnsNoop()
+    {
+        _root.WriteDeploymentLock();
+        var detector = new PendingUpdateDetector(
+            new DeploymentLocator(_root.AppRoot),
+            _root.Paths,
+            new UpdateSignatureVerifier(_root.Paths));
+
+        var result = detector.ValidateIncomingState();
+
+        Assert.True(result.Success);
+        Assert.Equal("noop", result.Code);
+    }
+
+    public void Dispose() => _root.Dispose();
+}
+
+public sealed class UpdateSignatureVerifierTests : IDisposable
+{
+    private readonly TempLauncherRoot _root = new();
+
+    [Fact]
+    public void Verify_WhenSignatureIsMissing_ReturnsStructuredFailure()
+    {
+        var payload = Path.Combine(_root.Paths.IncomingRoot, "files.json");
+        Directory.CreateDirectory(_root.Paths.IncomingRoot);
+        File.WriteAllText(payload, "{}");
+
+        var result = new UpdateSignatureVerifier(_root.Paths)
+            .Verify(payload, Path.Combine(_root.Paths.IncomingRoot, "files.json.sig"), "files.json.sig");
+
+        Assert.False(result.Success);
+        Assert.Equal("Missing files.json.sig.", result.Message);
+    }
+
+    public void Dispose() => _root.Dispose();
+}
+
+public sealed class IncomingArtifactsCleanerTests : IDisposable
+{
+    private readonly TempLauncherRoot _root = new();
+
+    [Fact]
+    public void Cleanup_RemovesLegacyPlondsAndCheckpointArtifacts()
+    {
+        Directory.CreateDirectory(_root.Paths.PlondsObjectsRoot);
+        foreach (var path in new[]
+                 {
+                     _root.Paths.FileMapPath,
+                     _root.Paths.SignaturePath,
+                     _root.Paths.ArchivePath,
+                     _root.Paths.PlondsFileMapPath,
+                     _root.Paths.PlondsSignaturePath,
+                     _root.Paths.PlondsUpdateMetadataPath,
+                     _root.Paths.InstallCheckpointPath,
+                     Path.Combine(_root.Paths.PlondsObjectsRoot, "payload")
+                 })
+        {
+            Directory.CreateDirectory(Path.GetDirectoryName(path)!);
+            File.WriteAllText(path, "x");
+        }
+
+        new IncomingArtifactsCleaner(_root.Paths).Cleanup();
+
+        Assert.False(File.Exists(_root.Paths.FileMapPath));
+        Assert.False(File.Exists(_root.Paths.InstallCheckpointPath));
+        Assert.False(Directory.Exists(_root.Paths.PlondsObjectsRoot));
+    }
+
+    public void Dispose() => _root.Dispose();
+}
+
+public sealed class DeploymentActivatorTests : IDisposable
+{
+    private readonly TempLauncherRoot _root = new();
+
+    [Fact]
+    public void Activate_MovesCurrentMarkerAndMarksPreviousDestroy()
+    {
+        var from = Path.Combine(_root.AppRoot, "app-1");
+        var to = Path.Combine(_root.AppRoot, "app-2");
+        Directory.CreateDirectory(from);
+        Directory.CreateDirectory(to);
+        File.WriteAllText(Path.Combine(from, ".current"), string.Empty);
+        File.WriteAllText(Path.Combine(to, ".partial"), string.Empty);
+
+        new DeploymentActivator(new DeploymentLocator(_root.AppRoot)).Activate(from, to);
+
+        Assert.False(File.Exists(Path.Combine(from, ".current")));
+        Assert.True(File.Exists(Path.Combine(from, ".destroy")));
+        Assert.True(File.Exists(Path.Combine(to, ".current")));
+        Assert.False(File.Exists(Path.Combine(to, ".partial")));
+    }
+
+    public void Dispose() => _root.Dispose();
+}
+
+public sealed class RollbackStrategyTests : IDisposable
+{
+    private readonly TempLauncherRoot _root = new();
+
+    [Fact]
+    public void RollbackLatest_WhenNoSnapshotsExist_ReturnsNoSnapshot()
+    {
+        var snapshotStore = new UpdateSnapshotStore(_root.Paths);
+        var activator = new DeploymentActivator(new DeploymentLocator(_root.AppRoot));
+
+        var result = new RollbackStrategy(new DeploymentLocator(_root.AppRoot), snapshotStore, activator)
+            .RollbackLatest();
+
+        Assert.False(result.Success);
+        Assert.Equal("no_snapshot", result.Code);
+    }
+
+    public void Dispose() => _root.Dispose();
+}
+
+public sealed class PlondsUpdateApplierTests
+{
+    [Fact]
+    public void ManifestParser_ReadsObjectComponentFiles()
+    {
+        var map = new PlondsFileMap();
+        var entries = PlondsManifestParser.CollectFileEntries(map);
+
+        PlondsManifestParser.PopulateFromRawJson(
+            """
+            {
+              "toVersion": "2.0.0",
+              "components": {
+                "desktop": {
+                  "files": {
+                    "LanMountainDesktop.exe": {
+                      "archiveSha512": "abcd",
+                      "archivePath": "objects/ab/cd"
+                    }
+                  }
+                }
+              }
+            }
+            """,
+            map,
+            entries);
+
+        Assert.Equal("2.0.0", PlondsManifestParser.ResolveTargetVersion(map, null));
+        var entry = Assert.Single(entries);
+        Assert.Equal("LanMountainDesktop.exe", entry.Path);
+        Assert.Equal("desktop", entry.Metadata["component"]);
+    }
+}
+
+public sealed class LegacyUpdateApplierTests : IDisposable
+{
+    private readonly TempLauncherRoot _root = new();
+
+    [Fact]
+    public async Task ApplyAsync_WhenSignatureIsMissing_ReturnsSignatureFailure()
+    {
+        _root.WriteDeploymentLock();
+        Directory.CreateDirectory(_root.Paths.IncomingRoot);
+        File.WriteAllText(_root.Paths.FileMapPath, JsonSerializer.Serialize(new SignedFileMap
+        {
+            FromVersion = "1.0.0",
+            ToVersion = "2.0.0",
+            Files = [new UpdateFileEntry { Path = "state.txt" }]
+        }, AppJsonContext.Default.SignedFileMap));
+        using (var archive = ZipFile.Open(_root.Paths.ArchivePath, ZipArchiveMode.Create))
+        {
+            var entry = archive.CreateEntry("state.txt");
+            await using var stream = entry.Open();
+            await stream.WriteAsync(Encoding.UTF8.GetBytes("state"));
+        }
+
+        var applier = CreateLegacyApplier();
+        var result = await applier.ApplyAsync();
+
+        Assert.False(result.Success);
+        Assert.Equal("signature_failed", result.Code);
+    }
+
+    public void Dispose() => _root.Dispose();
+
+    private LegacyUpdateApplier CreateLegacyApplier()
+    {
+        var locator = new DeploymentLocator(_root.AppRoot);
+        var snapshotStore = new UpdateSnapshotStore(_root.Paths);
+        var checkpointStore = new InstallCheckpointStore(_root.Paths);
+        var activator = new DeploymentActivator(locator);
+        var cleaner = new IncomingArtifactsCleaner(_root.Paths);
+        return new LegacyUpdateApplier(
+            locator,
+            _root.Paths,
+            new UpdateSignatureVerifier(_root.Paths),
+            new NullUpdateProgressReporter(),
+            snapshotStore,
+            checkpointStore,
+            activator,
+            cleaner);
+    }
+}
+
+internal sealed class TempLauncherRoot : IDisposable
+{
+    public TempLauncherRoot()
+    {
+        AppRoot = Path.Combine(Path.GetTempPath(), "lmd-launcher-tests", Guid.NewGuid().ToString("N"));
+        Directory.CreateDirectory(AppRoot);
+        Paths = new UpdateEnginePaths(AppRoot);
+        Directory.CreateDirectory(Paths.IncomingRoot);
+    }
+
+    public string AppRoot { get; }
+
+    public UpdateEnginePaths Paths { get; }
+
+    public void WriteDeploymentLock()
+    {
+        Directory.CreateDirectory(Path.GetDirectoryName(Paths.DeploymentLockPath)!);
+        File.WriteAllText(Paths.DeploymentLockPath, string.Empty);
+    }
+
+    public void Dispose()
+    {
+        try
+        {
+            if (Directory.Exists(AppRoot))
+            {
+                Directory.Delete(AppRoot, true);
+            }
+        }
+        catch
+        {
+        }
+    }
+}

LanMountainDesktop.Tests/WindowLayerIsolationTests.cs

@@ -130,7 +130,7 @@ public sealed class WindowLayerIsolationTests
     {
         var optionsSource = ReadRepositoryFile("LanMountainDesktop.AirAppHost", "AirAppLaunchOptions.cs");
         var programSource = ReadRepositoryFile("LanMountainDesktop.AirAppHost", "Program.cs");
-        var starterSource = ReadRepositoryFile("LanMountainDesktop.Launcher", "Services", "AirApp", "IAirAppProcessStarter.cs");
+        var starterSource = ReadRepositoryFile("LanMountainDesktop.Launcher", "AirApp", "IAirAppProcessStarter.cs");
         var dataPathSource = ReadRepositoryFile("LanMountainDesktop", "Services", "AppDataPathProvider.cs");
 
         Assert.Contains("DataRoot", optionsSource);