mirror of
https://github.com/wwiinnddyy/LanMountainDesktop.git
synced 2026-06-20 23:54:26 +08:00
649 lines
26 KiB
C#
649 lines
26 KiB
C#
using System.Net;
|
|
using System.Security.Cryptography;
|
|
using System.IO.Compression;
|
|
using LanMountainDesktop.Services.Plonds;
|
|
using Xunit;
|
|
|
|
namespace LanMountainDesktop.Tests;
|
|
|
|
public sealed class PlondsClientServiceTests : IDisposable
|
|
{
|
|
private readonly string _tempRoot = Path.Combine(
|
|
Path.GetTempPath(),
|
|
"LanMountainDesktop.Tests",
|
|
nameof(PlondsClientServiceTests),
|
|
Guid.NewGuid().ToString("N"));
|
|
|
|
public void Dispose()
|
|
{
|
|
if (Directory.Exists(_tempRoot))
|
|
{
|
|
Directory.Delete(_tempRoot, recursive: true);
|
|
}
|
|
}
|
|
|
|
[Fact]
|
|
public void SourceRegistry_AddRange_DeduplicatesAndAllowsManifestExtensions()
|
|
{
|
|
var registry = new PlondsSourceRegistry(
|
|
[
|
|
new("s3", "s3", "https://s3.test/PLONDS.json", 100),
|
|
new("github", "github", "https://github.test/PLONDS.json", 50)
|
|
]);
|
|
|
|
registry.AddRange(
|
|
[
|
|
new("mirror", "http", "https://mirror.test/PLONDS.json", 10),
|
|
new("s3", "s3", "https://s3-new.test/PLONDS.json", 200),
|
|
new("duplicate-url", "http", "https://mirror.test/PLONDS.json", 1)
|
|
]);
|
|
|
|
Assert.Equal(3, registry.Sources.Count);
|
|
Assert.Contains(registry.Sources, source => source.Id == "s3" && source.ManifestUrl == "https://s3-new.test/PLONDS.json");
|
|
Assert.Contains(registry.Sources, source => source.Id == "mirror");
|
|
}
|
|
|
|
[Fact]
|
|
public void ManifestSelector_WhenVersionsDiffer_SelectsHighestVersion()
|
|
{
|
|
var selected = PlondsManifestSelector.SelectHighestVersion(
|
|
[
|
|
new(new("s3", "s3", "https://s3.test/PLONDS.json", 100), CreateManifest("1.2.0")),
|
|
new(new("github", "github", "https://github.test/PLONDS.json", 50), CreateManifest("1.3.0")),
|
|
new(new("mirror", "http", "https://mirror.test/PLONDS.json", 500), CreateManifest("1.1.9"))
|
|
]);
|
|
|
|
Assert.NotNull(selected);
|
|
Assert.Equal("1.3.0", selected.Manifest.CurrentVersion);
|
|
Assert.Equal("github", selected.Source.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DownloadPlanner_WhenDeltaFails_FallsBackToFullPackage()
|
|
{
|
|
var downloader = new FakeDownloader(deltaFails: true, fullFails: false);
|
|
var planner = new PlondsDownloadPlanner(downloader);
|
|
|
|
var result = await planner.PrepareAsync(
|
|
new PlondsManifestCandidate(new("s3", "s3", "https://s3.test/PLONDS.json"), CreateManifest("1.2.3")),
|
|
CancellationToken.None);
|
|
|
|
Assert.True(result.Success);
|
|
Assert.False(result.RequiresUiHandling);
|
|
Assert.Equal(PlondsPackageMode.Full, result.Package?.Mode);
|
|
Assert.Equal(1, downloader.DeltaCalls);
|
|
Assert.Equal(1, downloader.FullCalls);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DownloadPlanner_WhenDeltaAndFullFail_ReturnsUiFailure()
|
|
{
|
|
var downloader = new FakeDownloader(deltaFails: true, fullFails: true);
|
|
var planner = new PlondsDownloadPlanner(downloader);
|
|
|
|
var result = await planner.PrepareAsync(
|
|
new PlondsManifestCandidate(new("s3", "s3", "https://s3.test/PLONDS.json"), CreateManifest("1.2.3")),
|
|
CancellationToken.None);
|
|
|
|
Assert.False(result.Success);
|
|
Assert.True(result.RequiresUiHandling);
|
|
Assert.Null(result.Package);
|
|
Assert.Contains("full package fallback also failed", result.ErrorMessage);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlondsService_ReadsBuiltInSources_RegistersManifestSources_AndPreparesHighestVersion()
|
|
{
|
|
using var httpClient = new HttpClient(new ManifestHandler(new Dictionary<string, string>
|
|
{
|
|
["https://s3.test/PLONDS.json"] = ManifestJson("1.2.0", """
|
|
"sources": [
|
|
{ "id": "mirror", "kind": "http", "manifestUrl": "https://mirror.test/PLONDS.json", "priority": 25 }
|
|
]
|
|
"""),
|
|
["https://github.test/PLONDS.json"] = ManifestJson("1.3.0")
|
|
}));
|
|
|
|
var registry = new PlondsSourceRegistry(
|
|
[
|
|
new("s3", "s3", "https://s3.test/PLONDS.json", 100),
|
|
new("github", "github", "https://github.test/PLONDS.json", 50)
|
|
]);
|
|
var downloader = new FakeDownloader(deltaFails: false, fullFails: false);
|
|
var service = new PlondsService(
|
|
registry,
|
|
new PlondsManifestClient(httpClient),
|
|
new PlondsDownloadPlanner(downloader));
|
|
|
|
var result = await service.FindAndPrepareLatestAsync(CancellationToken.None);
|
|
|
|
Assert.True(result.Success);
|
|
Assert.Equal("1.3.0", result.Package?.Version.ToString());
|
|
Assert.Equal(PlondsPackageMode.Delta, result.Package?.Mode);
|
|
Assert.Contains(registry.Sources, source => source.Id == "mirror" && source.ManifestUrl == "https://mirror.test/PLONDS.json");
|
|
}
|
|
|
|
[Fact]
|
|
public void ClientServiceFactory_CreatesBuiltInS3AndGitHubSources()
|
|
{
|
|
var sources = PlondsClientServiceFactory.CreateBuiltInSources();
|
|
|
|
Assert.Equal(2, sources.Count);
|
|
Assert.Contains(sources, source => source.Id == "s3" && source.Kind == "s3" && source.ManifestUrl.EndsWith("/PLONDS.json", StringComparison.Ordinal));
|
|
Assert.Contains(sources, source => source.Id == "github" && source.Kind == "github" && source.ManifestUrl.EndsWith("/PLONDS.json", StringComparison.Ordinal));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlondsService_FindLatest_UsesHighestVersionAndPersistsManifestSources()
|
|
{
|
|
using var httpClient = new HttpClient(new ManifestHandler(new Dictionary<string, string>
|
|
{
|
|
["https://s3.test/PLONDS.json"] = ManifestJson("1.5.0", """
|
|
"sources": [
|
|
{ "id": "mirror", "kind": "http", "manifestUrl": "https://mirror.test/PLONDS.json", "priority": 25 }
|
|
]
|
|
"""),
|
|
["https://github.test/PLONDS.json"] = ManifestJson("1.4.0")
|
|
}));
|
|
var sourceStorePath = Path.Combine(_tempRoot, "sources.json");
|
|
var sourceStore = new PlondsSourceStore(sourceStorePath);
|
|
var registry = new PlondsSourceRegistry(
|
|
[
|
|
new("s3", "s3", "https://s3.test/PLONDS.json", 100),
|
|
new("github", "github", "https://github.test/PLONDS.json", 50)
|
|
]);
|
|
var service = new PlondsService(
|
|
registry,
|
|
new PlondsManifestClient(httpClient),
|
|
new PlondsDownloadPlanner(new FakeDownloader(deltaFails: false, fullFails: false)),
|
|
sourceStore);
|
|
|
|
var result = await service.FindLatestAsync(new Version(1, 4, 0), CancellationToken.None);
|
|
var storedSources = await sourceStore.LoadAsync(CancellationToken.None);
|
|
|
|
Assert.True(result.Success);
|
|
Assert.True(result.IsUpdateAvailable);
|
|
Assert.Equal("1.5.0", result.LatestVersion?.ToString());
|
|
Assert.Contains(storedSources, source => source.Id == "mirror" && source.ManifestUrl == "https://mirror.test/PLONDS.json");
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlondsService_WhenHighestVersionSourcePackageFails_TriesSameVersionOtherSource()
|
|
{
|
|
using var httpClient = new HttpClient(new ManifestHandler(new Dictionary<string, string>
|
|
{
|
|
["https://s3.test/PLONDS.json"] = ManifestJson("1.6.0"),
|
|
["https://github.test/PLONDS.json"] = ManifestJson("1.6.0")
|
|
}));
|
|
var registry = new PlondsSourceRegistry(
|
|
[
|
|
new("s3", "s3", "https://s3.test/PLONDS.json", 100),
|
|
new("github", "github", "https://github.test/PLONDS.json", 50)
|
|
]);
|
|
var downloader = new SourceAwareFakeDownloader(failingSourceId: "s3");
|
|
var service = new PlondsService(
|
|
registry,
|
|
new PlondsManifestClient(httpClient),
|
|
new PlondsDownloadPlanner(downloader));
|
|
|
|
var result = await service.FindAndPrepareLatestAsync(new Version(1, 5, 0), CancellationToken.None);
|
|
|
|
Assert.True(result.Success);
|
|
Assert.Equal("github", downloader.SuccessfulSourceId);
|
|
Assert.Equal(2, downloader.DeltaCalls);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PlondsService_WhenManifestSourceThrows_ContinuesWithOtherSources()
|
|
{
|
|
using var httpClient = new HttpClient(new ManifestHandler(
|
|
new Dictionary<string, string>
|
|
{
|
|
["https://github.test/PLONDS.json"] = ManifestJson("1.7.0")
|
|
},
|
|
throwingUrls: new HashSet<string>(StringComparer.OrdinalIgnoreCase)
|
|
{
|
|
"https://s3.test/PLONDS.json"
|
|
}));
|
|
var registry = new PlondsSourceRegistry(
|
|
[
|
|
new("s3", "s3", "https://s3.test/PLONDS.json", 100),
|
|
new("github", "github", "https://github.test/PLONDS.json", 50)
|
|
]);
|
|
var service = new PlondsService(
|
|
registry,
|
|
new PlondsManifestClient(httpClient),
|
|
new PlondsDownloadPlanner(new FakeDownloader(deltaFails: false, fullFails: false)));
|
|
|
|
var result = await service.FindLatestAsync(new Version(1, 6, 0), CancellationToken.None);
|
|
|
|
Assert.True(result.Success);
|
|
Assert.True(result.IsUpdateAvailable);
|
|
Assert.Equal("1.7.0", result.LatestVersion?.ToString());
|
|
Assert.Equal("github", Assert.Single(result.Candidates).Source.Id);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task HttpDownloader_DownloadsVerifiesAndExtractsDeltaPackage()
|
|
{
|
|
var changedZip = CreateZip(("app.dll", "delta payload"));
|
|
var filesZip = CreateZip(("app.dll", "full payload"));
|
|
var manifest = CreateManifest(
|
|
"1.4.0",
|
|
downloads: CreateDownloads(
|
|
changedUrl: "https://s3.test/1.4.0/changed.zip",
|
|
filesUrl: "https://s3.test/1.4.0/Files.zip"),
|
|
checksums: new Dictionary<string, string>
|
|
{
|
|
["changed.zip"] = Md5Checksum(changedZip),
|
|
["Files.zip"] = Md5Checksum(filesZip)
|
|
});
|
|
|
|
using var httpClient = new HttpClient(new AssetHandler(new Dictionary<string, byte[]>
|
|
{
|
|
["https://s3.test/1.4.0/changed.zip"] = changedZip,
|
|
["https://s3.test/1.4.0/Files.zip"] = filesZip
|
|
}));
|
|
var downloader = CreateHttpDownloader(httpClient);
|
|
|
|
var package = await downloader.PrepareDeltaAsync(
|
|
manifest,
|
|
new("s3", "s3", "https://s3.test/1.4.0/PLONDS.json", 100),
|
|
CancellationToken.None);
|
|
|
|
Assert.Equal(PlondsPackageMode.Delta, package.Mode);
|
|
Assert.True(File.Exists(package.ManifestPath));
|
|
Assert.True(File.Exists(package.ChangedZipPath));
|
|
Assert.Equal("delta payload", File.ReadAllText(Path.Combine(package.ChangedDirectory!, "app.dll")));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DownloadPlanner_WhenDeltaChecksumFails_PreparesFullPackage()
|
|
{
|
|
var changedZip = CreateZip(("app.dll", "delta payload"));
|
|
var filesZip = CreateZip(("app.dll", "full payload"));
|
|
var manifest = CreateManifest(
|
|
"1.4.1",
|
|
downloads: CreateDownloads(
|
|
changedUrl: "https://s3.test/1.4.1/changed.zip",
|
|
filesUrl: "https://s3.test/1.4.1/Files.zip"),
|
|
checksums: new Dictionary<string, string>
|
|
{
|
|
["changed.zip"] = "md5:00000000000000000000000000000000",
|
|
["Files.zip"] = Md5Checksum(filesZip)
|
|
});
|
|
|
|
using var httpClient = new HttpClient(new AssetHandler(new Dictionary<string, byte[]>
|
|
{
|
|
["https://s3.test/1.4.1/changed.zip"] = changedZip,
|
|
["https://s3.test/1.4.1/Files.zip"] = filesZip
|
|
}));
|
|
var planner = new PlondsDownloadPlanner(CreateHttpDownloader(httpClient));
|
|
|
|
var result = await planner.PrepareAsync(
|
|
new PlondsManifestCandidate(new("s3", "s3", "https://s3.test/1.4.1/PLONDS.json", 100), manifest),
|
|
CancellationToken.None);
|
|
|
|
Assert.True(result.Success);
|
|
Assert.Equal(PlondsPackageMode.Full, result.Package?.Mode);
|
|
Assert.Equal("full payload", File.ReadAllText(Path.Combine(result.Package!.FilesDirectory!, "app.dll")));
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DownloadPlanner_WhenDeltaUrlMissing_PreparesFullPackage()
|
|
{
|
|
var filesZip = CreateZip(("app.dll", "full payload"));
|
|
var manifest = CreateManifest(
|
|
"1.4.2",
|
|
downloads: CreateDownloads(
|
|
changedUrl: null,
|
|
filesUrl: "https://s3.test/1.4.2/Files.zip"),
|
|
checksums: new Dictionary<string, string>
|
|
{
|
|
["Files.zip"] = Md5Checksum(filesZip)
|
|
});
|
|
|
|
using var httpClient = new HttpClient(new AssetHandler(new Dictionary<string, byte[]>
|
|
{
|
|
["https://s3.test/1.4.2/Files.zip"] = filesZip
|
|
}));
|
|
var planner = new PlondsDownloadPlanner(CreateHttpDownloader(httpClient));
|
|
|
|
var result = await planner.PrepareAsync(
|
|
new PlondsManifestCandidate(new("s3", "s3", "https://s3.test/1.4.2/PLONDS.json", 100), manifest),
|
|
CancellationToken.None);
|
|
|
|
Assert.True(result.Success);
|
|
Assert.Equal(PlondsPackageMode.Full, result.Package?.Mode);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task DownloadPlanner_WhenFullChecksumFails_ReturnsUiFailure()
|
|
{
|
|
var changedZip = CreateZip(("app.dll", "delta payload"));
|
|
var filesZip = CreateZip(("app.dll", "full payload"));
|
|
var manifest = CreateManifest(
|
|
"1.4.3",
|
|
downloads: CreateDownloads(
|
|
changedUrl: "https://s3.test/1.4.3/changed.zip",
|
|
filesUrl: "https://s3.test/1.4.3/Files.zip"),
|
|
checksums: new Dictionary<string, string>
|
|
{
|
|
["changed.zip"] = "md5:00000000000000000000000000000000",
|
|
["Files.zip"] = "md5:11111111111111111111111111111111"
|
|
});
|
|
|
|
using var httpClient = new HttpClient(new AssetHandler(new Dictionary<string, byte[]>
|
|
{
|
|
["https://s3.test/1.4.3/changed.zip"] = changedZip,
|
|
["https://s3.test/1.4.3/Files.zip"] = filesZip
|
|
}));
|
|
var planner = new PlondsDownloadPlanner(CreateHttpDownloader(httpClient));
|
|
|
|
var result = await planner.PrepareAsync(
|
|
new PlondsManifestCandidate(new("s3", "s3", "https://s3.test/1.4.3/PLONDS.json", 100), manifest),
|
|
CancellationToken.None);
|
|
|
|
Assert.False(result.Success);
|
|
Assert.True(result.RequiresUiHandling);
|
|
Assert.Contains("full package fallback also failed", result.ErrorMessage);
|
|
}
|
|
|
|
[Fact]
|
|
public async Task PreparedPackageInstaller_AppliesDeltaPackageWithoutUpdateDownloadSystem()
|
|
{
|
|
var launcherRoot = Path.Combine(_tempRoot, "launcher");
|
|
var currentDeployment = Path.Combine(launcherRoot, "app-1.0.0-0");
|
|
Directory.CreateDirectory(currentDeployment);
|
|
File.WriteAllText(Path.Combine(currentDeployment, ".current"), string.Empty);
|
|
File.WriteAllText(Path.Combine(currentDeployment, "LanMountainDesktop.exe"), "exe");
|
|
File.WriteAllText(Path.Combine(currentDeployment, "app.dll"), "old");
|
|
File.WriteAllText(Path.Combine(currentDeployment, "keep.txt"), "keep");
|
|
File.WriteAllText(Path.Combine(currentDeployment, "delete.txt"), "delete");
|
|
|
|
var changedDirectory = Path.Combine(_tempRoot, "changed");
|
|
Directory.CreateDirectory(changedDirectory);
|
|
File.WriteAllText(Path.Combine(changedDirectory, "app.dll"), "new");
|
|
var manifestPath = Path.Combine(_tempRoot, "PLONDS.json");
|
|
await File.WriteAllTextAsync(manifestPath, $$"""
|
|
{
|
|
"formatVersion": "2.0",
|
|
"currentVersion": "1.1.0",
|
|
"previousVersion": "1.0.0",
|
|
"isFullUpdate": false,
|
|
"requiresCleanInstall": false,
|
|
"channel": "stable",
|
|
"platform": "windows-x64",
|
|
"updatedAt": "2026-06-01T00:00:00Z",
|
|
"filesMap": {
|
|
"LanMountainDesktop.exe": { "action": "reuse", "hash": "{{Sha256Text("exe")}}", "size": 3 },
|
|
"app.dll": { "action": "replace", "hash": "{{Sha256Text("new")}}", "size": 3 },
|
|
"keep.txt": { "action": "reuse", "hash": "{{Sha256Text("keep")}}", "size": 4 },
|
|
"delete.txt": { "action": "delete", "hash": "", "size": 0 }
|
|
},
|
|
"changedFilesMap": {
|
|
"app.dll": { "archivePath": "app.dll", "hash": "{{Sha256Text("new")}}", "size": 3 }
|
|
},
|
|
"checksums": {}
|
|
}
|
|
""");
|
|
var package = new PlondsPreparedPackage(
|
|
new Version(1, 1, 0),
|
|
PlondsPackageMode.Delta,
|
|
manifestPath,
|
|
Path.Combine(_tempRoot, "changed.zip"),
|
|
changedDirectory,
|
|
null,
|
|
null);
|
|
|
|
var result = await new PlondsPreparedPackageInstaller().InstallAsync(
|
|
package,
|
|
launcherRoot,
|
|
progress: null,
|
|
CancellationToken.None);
|
|
|
|
Assert.True(result.Success);
|
|
var target = Assert.Single(Directory.GetDirectories(launcherRoot, "app-1.1.0-*"));
|
|
Assert.Equal("new", File.ReadAllText(Path.Combine(target, "app.dll")));
|
|
Assert.Equal("keep", File.ReadAllText(Path.Combine(target, "keep.txt")));
|
|
Assert.False(File.Exists(Path.Combine(target, "delete.txt")));
|
|
Assert.True(File.Exists(Path.Combine(target, ".current")));
|
|
Assert.True(File.Exists(Path.Combine(currentDeployment, ".destroy")));
|
|
}
|
|
|
|
private static PlondsClientManifest CreateManifest(
|
|
string version,
|
|
IReadOnlyList<PlondsSourceDescriptor>? sources = null,
|
|
PlondsClientDownloads? downloads = null,
|
|
IReadOnlyDictionary<string, string>? checksums = null)
|
|
{
|
|
return new PlondsClientManifest(
|
|
FormatVersion: "2.0",
|
|
CurrentVersion: version,
|
|
PreviousVersion: "1.0.0",
|
|
IsFullUpdate: false,
|
|
RequiresCleanInstall: false,
|
|
Channel: "stable",
|
|
Platform: "windows-x64",
|
|
UpdatedAt: DateTimeOffset.Parse("2026-06-01T00:00:00Z"),
|
|
FilesMap: new Dictionary<string, PlondsClientFileEntry>(),
|
|
ChangedFilesMap: new Dictionary<string, PlondsClientChangedFileEntry>(),
|
|
Checksums: checksums ?? new Dictionary<string, string>(),
|
|
Downloads: downloads,
|
|
Sources: sources ?? []);
|
|
}
|
|
|
|
private PlondsHttpPackageDownloader CreateHttpDownloader(HttpClient httpClient)
|
|
{
|
|
return new PlondsHttpPackageDownloader(
|
|
httpClient,
|
|
new PlondsPackageStore(_tempRoot),
|
|
new PlondsVerifier());
|
|
}
|
|
|
|
private static PlondsClientDownloads CreateDownloads(string? changedUrl, string? filesUrl)
|
|
{
|
|
return new PlondsClientDownloads(
|
|
GitHub: null,
|
|
S3: new PlondsS3Downloads(
|
|
Bucket: "bucket",
|
|
Prefix: "lanmountain/update/plonds/1.4.0",
|
|
ManifestKey: "lanmountain/update/plonds/1.4.0/PLONDS.json",
|
|
ManifestUrl: "https://s3.test/1.4.0/PLONDS.json",
|
|
ChangedZipKey: changedUrl is null ? null : "lanmountain/update/plonds/1.4.0/changed.zip",
|
|
ChangedZipUrl: changedUrl,
|
|
ChangedFolderKey: null,
|
|
ChangedFolderUrl: null,
|
|
FilesZipKey: filesUrl is null ? null : "lanmountain/update/plonds/1.4.0/Files.zip",
|
|
FilesZipUrl: filesUrl,
|
|
FilesFolderKey: null,
|
|
FilesFolderUrl: null));
|
|
}
|
|
|
|
private static byte[] CreateZip(params (string Path, string Contents)[] entries)
|
|
{
|
|
using var stream = new MemoryStream();
|
|
using (var archive = new ZipArchive(stream, ZipArchiveMode.Create, leaveOpen: true))
|
|
{
|
|
foreach (var (path, contents) in entries)
|
|
{
|
|
var entry = archive.CreateEntry(path);
|
|
using var writer = new StreamWriter(entry.Open());
|
|
writer.Write(contents);
|
|
}
|
|
}
|
|
|
|
return stream.ToArray();
|
|
}
|
|
|
|
private static string Md5Checksum(byte[] bytes)
|
|
{
|
|
return $"md5:{Convert.ToHexString(MD5.HashData(bytes)).ToLowerInvariant()}";
|
|
}
|
|
|
|
private static string Sha256Text(string text)
|
|
{
|
|
return Convert.ToHexString(SHA256.HashData(System.Text.Encoding.UTF8.GetBytes(text))).ToLowerInvariant();
|
|
}
|
|
|
|
private static string ManifestJson(string version, string extraFields = "")
|
|
{
|
|
var separator = string.IsNullOrWhiteSpace(extraFields) ? string.Empty : ",";
|
|
return $$"""
|
|
{
|
|
"formatVersion": "2.0",
|
|
"currentVersion": "{{version}}",
|
|
"previousVersion": "1.0.0",
|
|
"isFullUpdate": false,
|
|
"requiresCleanInstall": false,
|
|
"channel": "stable",
|
|
"platform": "windows-x64",
|
|
"updatedAt": "2026-06-01T00:00:00Z",
|
|
"filesMap": {},
|
|
"changedFilesMap": {},
|
|
"checksums": {}{{separator}}
|
|
{{extraFields}}
|
|
}
|
|
""";
|
|
}
|
|
|
|
private sealed class FakeDownloader(bool deltaFails, bool fullFails) : IPlondsPackageDownloader
|
|
{
|
|
public int DeltaCalls { get; private set; }
|
|
public int FullCalls { get; private set; }
|
|
|
|
public Task<PlondsPreparedPackage> PrepareDeltaAsync(
|
|
PlondsClientManifest manifest,
|
|
PlondsSourceDescriptor source,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
DeltaCalls++;
|
|
if (deltaFails)
|
|
{
|
|
throw new InvalidOperationException("delta failed");
|
|
}
|
|
|
|
return Task.FromResult(CreatePackage(manifest, PlondsPackageMode.Delta));
|
|
}
|
|
|
|
public Task<PlondsPreparedPackage> PrepareFullAsync(
|
|
PlondsClientManifest manifest,
|
|
PlondsSourceDescriptor source,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
FullCalls++;
|
|
if (fullFails)
|
|
{
|
|
throw new InvalidOperationException("full failed");
|
|
}
|
|
|
|
return Task.FromResult(CreatePackage(manifest, PlondsPackageMode.Full));
|
|
}
|
|
|
|
private static PlondsPreparedPackage CreatePackage(PlondsClientManifest manifest, PlondsPackageMode mode)
|
|
{
|
|
PlondsManifestSelector.TryParseVersion(manifest.CurrentVersion, out var version);
|
|
return new PlondsPreparedPackage(
|
|
version,
|
|
mode,
|
|
"PLONDS.json",
|
|
mode is PlondsPackageMode.Delta ? "changed.zip" : null,
|
|
mode is PlondsPackageMode.Delta ? "changed" : null,
|
|
mode is PlondsPackageMode.Full ? "Files.zip" : null,
|
|
mode is PlondsPackageMode.Full ? "Files" : null);
|
|
}
|
|
}
|
|
|
|
private sealed class SourceAwareFakeDownloader(string failingSourceId) : IPlondsPackageDownloader
|
|
{
|
|
public int DeltaCalls { get; private set; }
|
|
public string? SuccessfulSourceId { get; private set; }
|
|
|
|
public Task<PlondsPreparedPackage> PrepareDeltaAsync(
|
|
PlondsClientManifest manifest,
|
|
PlondsSourceDescriptor source,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
DeltaCalls++;
|
|
if (string.Equals(source.Id, failingSourceId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
throw new InvalidOperationException("source failed");
|
|
}
|
|
|
|
SuccessfulSourceId = source.Id;
|
|
return Task.FromResult(CreatePackage(manifest, source, PlondsPackageMode.Delta));
|
|
}
|
|
|
|
public Task<PlondsPreparedPackage> PrepareFullAsync(
|
|
PlondsClientManifest manifest,
|
|
PlondsSourceDescriptor source,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (string.Equals(source.Id, failingSourceId, StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
throw new InvalidOperationException("source full failed");
|
|
}
|
|
|
|
SuccessfulSourceId = source.Id;
|
|
return Task.FromResult(CreatePackage(manifest, source, PlondsPackageMode.Full));
|
|
}
|
|
|
|
private static PlondsPreparedPackage CreatePackage(
|
|
PlondsClientManifest manifest,
|
|
PlondsSourceDescriptor source,
|
|
PlondsPackageMode mode)
|
|
{
|
|
PlondsManifestSelector.TryParseVersion(manifest.CurrentVersion, out var version);
|
|
return new PlondsPreparedPackage(
|
|
version,
|
|
mode,
|
|
$"{source.Id}/PLONDS.json",
|
|
mode is PlondsPackageMode.Delta ? $"{source.Id}/changed.zip" : null,
|
|
mode is PlondsPackageMode.Delta ? $"{source.Id}/changed" : null,
|
|
mode is PlondsPackageMode.Full ? $"{source.Id}/Files.zip" : null,
|
|
mode is PlondsPackageMode.Full ? $"{source.Id}/Files" : null);
|
|
}
|
|
}
|
|
|
|
private sealed class ManifestHandler(
|
|
IReadOnlyDictionary<string, string> manifests,
|
|
IReadOnlySet<string>? throwingUrls = null) : HttpMessageHandler
|
|
{
|
|
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
|
|
{
|
|
var url = request.RequestUri?.ToString() ?? string.Empty;
|
|
if (throwingUrls?.Contains(url) == true)
|
|
{
|
|
throw new HttpRequestException("manifest source failed");
|
|
}
|
|
|
|
if (!manifests.TryGetValue(url, out var json))
|
|
{
|
|
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound));
|
|
}
|
|
|
|
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
|
{
|
|
Content = new StringContent(json)
|
|
});
|
|
}
|
|
}
|
|
|
|
private sealed class AssetHandler(IReadOnlyDictionary<string, byte[]> assets) : HttpMessageHandler
|
|
{
|
|
protected override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
|
|
{
|
|
var url = request.RequestUri?.ToString() ?? string.Empty;
|
|
if (!assets.TryGetValue(url, out var bytes))
|
|
{
|
|
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.NotFound));
|
|
}
|
|
|
|
return Task.FromResult(new HttpResponseMessage(HttpStatusCode.OK)
|
|
{
|
|
Content = new ByteArrayContent(bytes)
|
|
});
|
|
}
|
|
}
|
|
}
|