-
This is another custom scripted co-op mission map. 1 or 2 humans players as GLA against 1 China…
-
Author: El_Chapo
+
+
+
+
+
+
Multiplayer-only
+
2 Players
+
+
This is another custom scripted co-op mission map. 1 or 2 humans players as GLA against 1 China…
+
+ El_Chapo
+ 2397 downloads
+
+
+
";
@@ -184,16 +192,70 @@ COOP GLA vs CHI - Call of Dragon
Assert.Equal(string.Format(CNCLabsConstants.MapIdFormat, 3239), item.Id);
Assert.Equal("COOP GLA vs CHI - Call of Dragon", item.Name);
- Assert.Equal("This is another custom scripted co-op mission map. 1 or 2 humans players as GLA against 1 China…", item.Description);
Assert.Equal("El_Chapo", item.AuthorName);
Assert.Equal(GenHub.Core.Models.Enums.ContentType.Map, item.ContentType);
Assert.Equal(GameType.Generals, item.TargetGame);
Assert.Equal(CNCLabsConstants.ResolverId, item.ResolverId);
Assert.True(item.RequiresResolution);
Assert.Equal(CNCLabsConstants.SourceName, item.ProviderName);
- Assert.Equal("/downloads/details.aspx?id=3239", item.SourceUrl);
+ Assert.Equal("https://www.cnclabs.com/downloads/details/3239/", item.SourceUrl);
Assert.True(item.ResolverMetadata.ContainsKey(CNCLabsConstants.MapIdMetadataKey));
Assert.Equal("3239", item.ResolverMetadata[CNCLabsConstants.MapIdMetadataKey]);
+ Assert.Equal("This is another custom scripted co-op mission map. 1 or 2 humans players as GLA against 1 China…", item.Description);
+
+ // Badges parsed from span.badge become tags, and the player-count badge is promoted
+ // into badge metadata by PromoteFromTags.
+ Assert.Contains("Multiplayer-only", item.Tags);
+ Assert.Contains("2 Players", item.Tags);
+ Assert.Equal("2", item.ResolverMetadata[GenHub.Core.Constants.ContentConstants.PlayerCountMetadataKey]);
+ }
+
+ ///
+ /// Verifies that
+ /// correctly identifies more items when the "Next" link is present.
+ ///
+ ///
A task representing the asynchronous test operation.
+ [Fact]
+ public async Task DiscoverAsync_WithNextLink_SetsHasMoreItemsTrueAsync()
+ {
+ // Arrange
+ var query = new ContentSearchQuery
+ {
+ TargetGame = GameType.Generals,
+ ContentType = GenHub.Core.Models.Enums.ContentType.Map,
+ Page = 1,
+ };
+
+ var html = @"
+
+
+
+";
+
+ using var http = CreateHttpClient(_ =>
+ new HttpResponseMessage(HttpStatusCode.OK)
+ {
+ Content = new StringContent(html),
+ });
+
+ var sut = CreateSut(http);
+
+ // Act
+ var result = await sut.DiscoverAsync(query);
+
+ // Assert
+ Assert.True(result.Success);
+ Assert.True(result.Data!.HasMoreItems);
}
// ---- helpers ----------------------------------------------------------
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/Common/ArchivePayloadProcessorTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/Common/ArchivePayloadProcessorTests.cs
new file mode 100644
index 000000000..c2accc100
--- /dev/null
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/Common/ArchivePayloadProcessorTests.cs
@@ -0,0 +1,827 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Threading.Tasks;
+using GenHub.Core.Models.Enums;
+using GenHub.Features.Content.Services.Common;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+using ContentType = GenHub.Core.Models.Enums.ContentType;
+
+namespace GenHub.Tests.Core.Features.Content.Common;
+
+///
+/// Unit tests for archive payload processing and directory structure normalization.
+///
+public sealed class ArchivePayloadProcessorTests : IDisposable
+{
+ private readonly string _stagingDirectory = Path.Combine(Path.GetTempPath(), "GenHubPayloadTests", Guid.NewGuid().ToString("N"));
+
+ ///
+ /// Verifies that extracting a valid ZIP archive unpacks all entries and removes the archive file.
+ ///
+ ///
A representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_ValidZip_ExtractsAllEntriesAndDeletesZipAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var zipPath = Path.Combine(_stagingDirectory, "test.zip");
+ {
+ using var archive = ZipFile.Open(zipPath, ZipArchiveMode.Create);
+ {
+ using var writer1 = new StreamWriter(archive.CreateEntry("Data/INI/GameData.ini").Open());
+ await writer1.WriteAsync("GameData=1");
+ }
+
+ {
+ using var writer2 = new StreamWriter(archive.CreateEntry("Art/Textures/test.tga").Open());
+ await writer2.WriteAsync("Texture");
+ }
+ }
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.ExtractArchivesSafelyAsync(_stagingDirectory);
+
+ // Assert
+ Assert.False(File.Exists(zipPath));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Data", "INI", "GameData.ini")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Art", "Textures", "test.tga")));
+ }
+
+ ///
+ /// Verifies that multi-level nested wrapper directories (e.g. ModDB mods like C&C Generals Undone)
+ /// are recursively flattened so game assets end up directly at the workspace root.
+ ///
+ ///
A representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_MultiLevelSingleWrapper_FlattensToRootAsync()
+ {
+ // Arrange
+ var nestedDir = Path.Combine(_stagingDirectory, "C&C Generals Undone v1.0", "C&C Generals Undone v1.0");
+ Directory.CreateDirectory(Path.Combine(nestedDir, "Art", "Textures"));
+ Directory.CreateDirectory(Path.Combine(nestedDir, "Data", "INI"));
+ Directory.CreateDirectory(Path.Combine(nestedDir, "Window"));
+
+ await File.WriteAllTextAsync(Path.Combine(nestedDir, "Readme.txt"), "Generals Undone Readme");
+ await File.WriteAllTextAsync(Path.Combine(nestedDir, "Art", "Textures", "test.tga"), "texture data");
+ await File.WriteAllTextAsync(Path.Combine(nestedDir, "Data", "INI", "GameData.ini"), "data");
+ await File.WriteAllTextAsync(Path.Combine(nestedDir, "Window", "MainMenu.wnd"), "window");
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour);
+
+ // Assert
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Readme.txt")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Art", "Textures", "test.tga")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Data", "INI", "GameData.ini")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Window", "MainMenu.wnd")));
+
+ // Old wrapper paths should no longer exist
+ Assert.False(Directory.Exists(Path.Combine(_stagingDirectory, "C&C Generals Undone v1.0")));
+ }
+
+ ///
+ /// Verifies that loose documentation files at root alongside a single mod wrapper directory
+ /// are reconciled by promoting the mod contents to the root and keeping the documentation files.
+ ///
+ ///
A representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_LooseReadmeWithModWrapper_FlattensModWrapperAlongsideReadmeAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ await File.WriteAllTextAsync(Path.Combine(_stagingDirectory, "Readme.txt"), "Important instructions");
+ await File.WriteAllTextAsync(Path.Combine(_stagingDirectory, "ModDB_Link.url"), "https://www.moddb.com");
+
+ var modDir = Path.Combine(_stagingDirectory, "GeneralsUndone");
+ Directory.CreateDirectory(Path.Combine(modDir, "Data", "INI"));
+ Directory.CreateDirectory(Path.Combine(modDir, "Art", "Textures"));
+ await File.WriteAllTextAsync(Path.Combine(modDir, "Data", "INI", "GameData.ini"), "inidata");
+ await File.WriteAllTextAsync(Path.Combine(modDir, "Art", "Textures", "unit.tga"), "tgadata");
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour);
+
+ // Assert
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Readme.txt")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "ModDB_Link.url")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Data", "INI", "GameData.ini")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Art", "Textures", "unit.tga")));
+ Assert.False(Directory.Exists(modDir));
+ }
+
+ ///
+ /// Verifies that game-specific subdirectories matching the target game (e.g. "Zero Hour")
+ /// are promoted to the payload root.
+ ///
+ ///
A representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_GameSpecificSubdirectory_PromotesMatchingTargetGameFolderAsync()
+ {
+ // Arrange
+ var zhDir = Path.Combine(_stagingDirectory, "Zero Hour", "Data", "INI");
+ Directory.CreateDirectory(zhDir);
+ await File.WriteAllTextAsync(Path.Combine(zhDir, "ZHData.ini"), "zh config");
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour);
+
+ // Assert
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Data", "INI", "ZHData.ini")));
+ Assert.False(Directory.Exists(Path.Combine(_stagingDirectory, "Zero Hour")));
+ }
+
+ ///
+ /// Verifies that single map directories for ContentType.Map are preserved with their map folder.
+ ///
+ ///
A representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_MapContent_PreservesSingleMapDirectoryAsync()
+ {
+ // Arrange
+ var mapDir = Path.Combine(_stagingDirectory, "Lemuria");
+ Directory.CreateDirectory(mapDir);
+ await File.WriteAllTextAsync(Path.Combine(mapDir, "Lemuria.map"), "map payload");
+ await File.WriteAllTextAsync(Path.Combine(mapDir, "Lemuria.tga"), "preview payload");
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Map, GameType.ZeroHour);
+
+ // Assert
+ Assert.True(Directory.Exists(mapDir));
+ Assert.True(File.Exists(Path.Combine(mapDir, "Lemuria.map")));
+ Assert.True(File.Exists(Path.Combine(mapDir, "Lemuria.tga")));
+ }
+
+ ///
+ /// Verifies that double-wrapped map archives (e.g. MapDownload/MapName/MapName.map)
+ /// strip only the outer wrapper while preserving the inner map folder.
+ ///
+ ///
A representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_MapContentWithDoubleWrapper_FlattensOuterWrapperOnlyAsync()
+ {
+ // Arrange
+ var outerWrapper = Path.Combine(_stagingDirectory, "MapDownloadWrapper");
+ var mapDir = Path.Combine(outerWrapper, "Lemuria");
+ Directory.CreateDirectory(mapDir);
+ await File.WriteAllTextAsync(Path.Combine(mapDir, "Lemuria.map"), "map payload");
+ await File.WriteAllTextAsync(Path.Combine(mapDir, "Lemuria.tga"), "preview payload");
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Map, GameType.ZeroHour);
+
+ // Assert
+ Assert.False(Directory.Exists(outerWrapper));
+ Assert.True(Directory.Exists(Path.Combine(_stagingDirectory, "Lemuria")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Lemuria", "Lemuria.map")));
+ }
+
+ ///
+ /// Verifies that system junk files (.DS_Store, Thumbs.db, desktop.ini, __MACOSX)
+ /// are purged during normalization.
+ ///
+ ///
A representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_PurgesSystemJunkAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(Path.Combine(_stagingDirectory, "__MACOSX"));
+ Directory.CreateDirectory(Path.Combine(_stagingDirectory, "Data"));
+
+ await File.WriteAllTextAsync(Path.Combine(_stagingDirectory, ".DS_Store"), "junk");
+ await File.WriteAllTextAsync(Path.Combine(_stagingDirectory, "Thumbs.db"), "junk");
+ await File.WriteAllTextAsync(Path.Combine(_stagingDirectory, "desktop.ini"), "junk");
+ await File.WriteAllTextAsync(Path.Combine(_stagingDirectory, "__MACOSX", "._something"), "junk");
+ await File.WriteAllTextAsync(Path.Combine(_stagingDirectory, "Data", "GameData.ini"), "real data");
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour);
+
+ // Assert
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, ".DS_Store")));
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, "Thumbs.db")));
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, "desktop.ini")));
+ Assert.False(Directory.Exists(Path.Combine(_stagingDirectory, "__MACOSX")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Data", "GameData.ini")));
+ }
+
+ ///
+ /// Verifies that an HTML error page pretending to be an archive is rejected.
+ ///
+ ///
A representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_HtmlErrorPayload_ThrowsInvalidDataExceptionAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var fakeZip = Path.Combine(_stagingDirectory, "broken.zip");
+ await File.WriteAllTextAsync(fakeZip, "Error 404 Not Found");
+
+ var processor = CreateProcessor();
+
+ // Act & Assert
+ var ex = await Assert.ThrowsAsync
(
+ () => processor.ExtractArchivesSafelyAsync(_stagingDirectory));
+ Assert.Contains("HTML", ex.Message, StringComparison.OrdinalIgnoreCase);
+ }
+
+ ///
+ /// Verifies that a self-extracting .exe archive for a Mod is extracted safely and the source .exe is removed.
+ ///
+ /// A representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_SelfExtractingExeMod_ExtractsAndDeletesExeAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var sfxExePath = Path.Combine(_stagingDirectory, "ShockWaveV1201.exe");
+ using (var archive = ZipFile.Open(sfxExePath, ZipArchiveMode.Create))
+ {
+ var entry = archive.CreateEntry("!ShockWave.big");
+ using var writer = new StreamWriter(entry.Open());
+ await writer.WriteAsync("BIG data payload");
+ }
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.ExtractArchivesSafelyAsync(_stagingDirectory, ContentType.Mod);
+
+ // Assert
+ Assert.False(File.Exists(sfxExePath));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "!ShockWave.big")));
+ }
+
+ ///
+ /// Verifies that executable files for tools or executables are never extracted or deleted even if they are zip containers.
+ ///
+ /// A representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_ExecutableTool_DoesNotExtractOrDeleteExeAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var toolExePath = Path.Combine(_stagingDirectory, "WorldBuilder.exe");
+ using (var archive = ZipFile.Open(toolExePath, ZipArchiveMode.Create))
+ {
+ var entry = archive.CreateEntry("internal.dll");
+ using var writer = new StreamWriter(entry.Open());
+ await writer.WriteAsync("dll");
+ }
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.ExtractArchivesSafelyAsync(_stagingDirectory, ContentType.ModdingTool);
+
+ // Assert: Tool executable is preserved intact and NOT extracted
+ Assert.True(File.Exists(toolExePath));
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, "internal.dll")));
+ }
+
+ ///
+ /// Verifies that non-archive game.dat files are skipped and preserved.
+ ///
+ /// A representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_GameDatBinary_PreservedWithoutThrowingAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var gameDatPath = Path.Combine(_stagingDirectory, "game.dat");
+ await File.WriteAllTextAsync(gameDatPath, "MZ_Binary_Executable_Payload_Not_Archive");
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.ExtractArchivesSafelyAsync(_stagingDirectory, ContentType.Patch);
+
+ // Assert
+ Assert.True(File.Exists(gameDatPath));
+ }
+
+ ///
+ /// Verifies that valid .dat archives (e.g. 10zh.dat) are extracted.
+ ///
+ /// A representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_ValidDatArchive_ExtractsAndDeletesDatAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var datArchivePath = Path.Combine(_stagingDirectory, "10zh.dat");
+ using (var archive = ZipFile.Open(datArchivePath, ZipArchiveMode.Create))
+ {
+ var entry = archive.CreateEntry("ZH/game.dat");
+ using var writer = new StreamWriter(entry.Open());
+ await writer.WriteAsync("ZH game binary");
+ }
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.ExtractArchivesSafelyAsync(_stagingDirectory, ContentType.Patch);
+
+ // Assert
+ Assert.False(File.Exists(datArchivePath));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "ZH", "game.dat")));
+ }
+
+ ///
+ /// Verifies that inactive .gib mod files are renamed to .big during normalization.
+ ///
+ /// A representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_GibFiles_NormalizesToBigAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var gibPath = Path.Combine(_stagingDirectory, "!ShwAudio.gib");
+ var bigHeader = new byte[] { (byte)'B', (byte)'I', (byte)'G', (byte)'F', 0x00, 0x10, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00 };
+ await File.WriteAllBytesAsync(gibPath, bigHeader);
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour);
+
+ // Assert
+ Assert.False(File.Exists(gibPath));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "!ShwAudio.big")));
+ }
+
+ ///
+ /// Verifies that inactive .ctr mod files (e.g. Contra) are renamed to .big during default normalization.
+ ///
+ /// A representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_CtrFiles_NormalizesToBigAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var ctrPath = Path.Combine(_stagingDirectory, "!ContraXBeta2_INI.ctr");
+ var bigHeader = new byte[] { (byte)'B', (byte)'I', (byte)'G', (byte)'F', 0x00, 0x10, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00 };
+ await File.WriteAllBytesAsync(ctrPath, bigHeader);
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour);
+
+ // Assert
+ Assert.False(File.Exists(ctrPath));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "!ContraXBeta2_INI.big")));
+ }
+
+ ///
+ /// Verifies that when normalizeInactiveArchives is false, .ctr and .gib files are preserved intact for Launcher Flow.
+ ///
+ /// A representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_WithNormalizeInactiveArchivesFalse_PreservesCtrAndGibFilesAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var ctrPath = Path.Combine(_stagingDirectory, "!ContraXBeta2_INI.ctr");
+ var gibPath = Path.Combine(_stagingDirectory, "!ROTRAudio.gib");
+ await File.WriteAllTextAsync(ctrPath, "Contra INI");
+ await File.WriteAllTextAsync(gibPath, "ROTR Audio");
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour, normalizeInactiveArchives: false);
+
+ // Assert
+ Assert.True(File.Exists(ctrPath));
+ Assert.True(File.Exists(gibPath));
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, "!ContraXBeta2_INI.big")));
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, "!ROTRAudio.big")));
+ }
+
+ ///
+ /// Verifies that self-extracting executable archives (e.g. ShockWaveV1201.exe with PE header followed by ZIP central directory)
+ /// are detected and extracted safely for mod content types.
+ ///
+ /// A representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_SelfExtractingExeArchive_ExtractsAndDeletesExeAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var sfxExePath = Path.Combine(_stagingDirectory, "ShockWaveV1201.exe");
+
+ using (var memoryStream = new MemoryStream())
+ {
+ var peHeader = new byte[512];
+ peHeader[0] = 0x4D; // 'M'
+ peHeader[1] = 0x5A; // 'Z'
+ memoryStream.Write(peHeader, 0, peHeader.Length);
+
+ using (var zipArchive = new ZipArchive(memoryStream, ZipArchiveMode.Create, leaveOpen: true))
+ {
+ {
+ var entry1 = zipArchive.CreateEntry("Data/INI/ShockWave.ini");
+ using var writer1 = new StreamWriter(entry1.Open());
+ await writer1.WriteAsync("ModName=ShockWave");
+ }
+
+ {
+ var entry2 = zipArchive.CreateEntry("!ShwAudio.gib");
+ using var writer2 = new StreamWriter(entry2.Open());
+ await writer2.WriteAsync("Audio content");
+ }
+ }
+
+ await File.WriteAllBytesAsync(sfxExePath, memoryStream.ToArray());
+ }
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.ExtractArchivesSafelyAsync(_stagingDirectory, ContentType.Mod);
+
+ // Assert
+ Assert.False(File.Exists(sfxExePath));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Data", "INI", "ShockWave.ini")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "!ShwAudio.gib")));
+ }
+
+ ///
+ /// Verifies that Smart Install Maker SFX executables (e.g. ShockWave) are safely extracted and normalized.
+ ///
+ /// A task representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_WithSmartInstallMakerExecutable_ExtractsAndNormalizesSuccessfully()
+ {
+ var casPath = @"A:\Steam\steamapps\common\.genhub-cas\objects\f4\f45e14d6b4a1e6e6feaa2ad737528b385586ad81ab7535bf9a330972db834c4e";
+ if (!File.Exists(casPath))
+ {
+ return;
+ }
+
+ var testDir = Path.Combine(_stagingDirectory, "sim_test_" + Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(testDir);
+
+ var installerPath = Path.Combine(testDir, "ShockWaveV1201.exe");
+ File.Copy(casPath, installerPath, overwrite: true);
+
+ var processor = CreateProcessor();
+
+ // 1. Extract archive safely
+ await processor.ExtractArchivesSafelyAsync(testDir, ContentType.Mod);
+
+ // 2. Original installer .exe should have been deleted after extraction
+ Assert.False(File.Exists(installerPath), "Installer executable should be removed after successful extraction.");
+
+ // 3. Normalize directory structure
+ await processor.NormalizeDirectoryStructureAsync(testDir, ContentType.Mod, GameType.ZeroHour);
+
+ // 4. Verify extracted and normalized game files exist with full uncompressed size
+ var textureBigPath = Path.Combine(testDir, "!ShwTextures.big");
+ Assert.True(File.Exists(textureBigPath), "Expected !ShwTextures.big to exist after normalization.");
+ var textureInfo = new FileInfo(textureBigPath);
+ Assert.True(textureInfo.Length > 60_000_000, $"Expected full textures >60MB, got {textureInfo.Length} bytes.");
+
+ Assert.True(
+ File.Exists(Path.Combine(testDir, "!!0ShwPtchIcon.big")),
+ "Expected !!0ShwPtchIcon.big to exist.");
+ Assert.True(
+ File.Exists(Path.Combine(testDir, "!ShwAudio.big")),
+ "Expected !ShwAudio.big to exist.");
+ Assert.True(
+ File.Exists(Path.Combine(testDir, "ShockWaveLauncher.exe")),
+ "Expected ShockWaveLauncher.exe to exist.");
+ }
+
+ ///
+ /// Verifies that payloads containing nested archives exceeding maximum extraction depth throw InvalidDataException.
+ ///
+ /// A task representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_ExceedsMaxNestedDepth_ThrowsInvalidDataExceptionAsync()
+ {
+ // Arrange: create 6 layers of nested zips
+ Directory.CreateDirectory(_stagingDirectory);
+ var currentZip = Path.Combine(_stagingDirectory, "nested_level_6.zip");
+ {
+ using var archive = ZipFile.Open(currentZip, ZipArchiveMode.Create);
+ using var writer = new StreamWriter(archive.CreateEntry("Data/test.ini").Open());
+ await writer.WriteAsync("data=1");
+ }
+
+ for (var i = 5; i >= 1; i--)
+ {
+ var nextZip = Path.Combine(_stagingDirectory, $"nested_level_{i}.zip");
+ using (var archive = ZipFile.Open(nextZip, ZipArchiveMode.Create))
+ {
+ archive.CreateEntryFromFile(currentZip, Path.GetFileName(currentZip));
+ }
+
+ File.Delete(currentZip);
+ currentZip = nextZip;
+ }
+
+ var processor = CreateProcessor();
+
+ // Act & Assert
+ await Assert.ThrowsAsync(() =>
+ processor.ExtractArchivesSafelyAsync(_stagingDirectory));
+ }
+
+ ///
+ /// Verifies that wrapper promotion with colliding files preserving both files when content differs.
+ ///
+ /// A task representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_WrapperCollisionWithDifferentContent_PreservesBothFilesAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var wrapperDir = Path.Combine(_stagingDirectory, "WrapperFolder");
+ Directory.CreateDirectory(Path.Combine(wrapperDir, "Data"));
+
+ // File at root
+ await File.WriteAllTextAsync(Path.Combine(_stagingDirectory, "Readme.txt"), "Root Readme content");
+
+ // File inside wrapper with same name but different content
+ await File.WriteAllTextAsync(Path.Combine(wrapperDir, "Readme.txt"), "Wrapper Readme content");
+ await File.WriteAllTextAsync(Path.Combine(wrapperDir, "Data", "GameData.ini"), "data=1");
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour);
+
+ // Assert
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Readme.txt")));
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Readme_1.txt")));
+ var rootText = await File.ReadAllTextAsync(Path.Combine(_stagingDirectory, "Readme.txt"));
+ var wrapperText = await File.ReadAllTextAsync(Path.Combine(_stagingDirectory, "Readme_1.txt"));
+ Assert.Contains("Readme content", rootText);
+ Assert.Contains("Readme content", wrapperText);
+ Assert.NotEqual(rootText, wrapperText);
+ }
+
+ ///
+ /// Verifies that archive normalization safely distinguishes between real BIG archives and MZ disguised executables.
+ /// Real BIG archives become .big, whereas MZ executables become .exe and are never named .big.
+ ///
+ /// A task representing the asynchronous unit test.
+ [Fact]
+ public async Task NormalizeDirectoryStructureAsync_WithDisguisedExecutableAndBigArchive_NormalizesSafelyAsync()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+
+ // Disguised executable (MZ header) named generals.ctr
+ var exeCtrPath = Path.Combine(_stagingDirectory, "generals.ctr");
+ var mzBytes = new byte[] { (byte)'M', (byte)'Z', 0x90, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00 };
+ await File.WriteAllBytesAsync(exeCtrPath, mzBytes);
+
+ // Real BIG archive (BIGF header) named !Contra.ctr
+ var bigCtrPath = Path.Combine(_stagingDirectory, "!Contra.ctr");
+ var bigBytes = new byte[] { (byte)'B', (byte)'I', (byte)'G', (byte)'F', 0x00, 0x10, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00 };
+ await File.WriteAllBytesAsync(bigCtrPath, bigBytes);
+
+ var processor = CreateProcessor();
+
+ // Act
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour, normalizeInactiveArchives: true);
+
+ // Assert
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "!Contra.big")), "!Contra.ctr with BIGF magic should become !Contra.big");
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, "!Contra.ctr")), "!Contra.ctr should no longer exist");
+
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "generals.exe")), "generals.ctr with MZ magic should become generals.exe");
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, "generals.big")), "generals.ctr MUST NEVER become generals.big");
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, "generals.ctr")), "generals.ctr should no longer exist");
+ }
+
+ ///
+ /// Verifies that Smart Install Maker executables with BZip2 and ZLib streams, uninstaller entries, and .ctr archives
+ /// are successfully unpacked and normalized without requiring external assets.
+ ///
+ /// A task representing the asynchronous unit test.
+ [Fact]
+ public async Task ExtractArchivesSafelyAsync_WithSyntheticSmartInstallMakerExecutable_ExtractsAndNormalizesSuccessfully()
+ {
+ // Arrange
+ Directory.CreateDirectory(_stagingDirectory);
+ var bigHeader = new byte[] { (byte)'B', (byte)'I', (byte)'G', (byte)'F', 0x10, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00, 0x00 };
+ var bigPayload = System.Text.Encoding.ASCII.GetBytes("TestIniDataInsideBig");
+ var bigContent = bigHeader.Concat(bigPayload).ToArray();
+
+ var exeHeader = new byte[] { (byte)'M', (byte)'Z', 0x90, 0x00, 0x03, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0xFF, 0xFF, 0x00, 0x00 };
+ var exePayload = System.Text.Encoding.ASCII.GetBytes("LauncherCode");
+ var exeContent = exeHeader.Concat(exePayload).ToArray();
+
+ var iniContent = System.Text.Encoding.ASCII.GetBytes("GameData=1\r\nVersion=1.0\r\n");
+
+ var syntheticSimBytes = CreateSyntheticSmartInstallMakerExecutable(
+ [
+ ("!ContraData.ctr", bigContent, true),
+ ("Contra_Launcher.exe", exeContent, true),
+ ("Data/INI/GameData.ini", iniContent, false),
+ ],
+ includeUninstallerEntry: true);
+
+ var installerPath = Path.Combine(_stagingDirectory, "ContraXBeta2Setup.exe");
+ await File.WriteAllBytesAsync(installerPath, syntheticSimBytes);
+
+ var processor = CreateProcessor();
+
+ // Act: 1. Extract archive safely
+ await processor.ExtractArchivesSafelyAsync(_stagingDirectory, ContentType.Mod);
+
+ // Assert: installer executable should be deleted after successful extraction
+ Assert.False(File.Exists(installerPath), "Installer executable should be deleted after extraction.");
+
+ // Act: 2. Normalize directory structure
+ await processor.NormalizeDirectoryStructureAsync(_stagingDirectory, ContentType.Mod, GameType.ZeroHour, normalizeInactiveArchives: true);
+
+ // Assert: extracted files exist and .ctr is normalized to .big
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "!ContraData.big")), "Expected !ContraData.ctr to be normalized to !ContraData.big");
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Contra_Launcher.exe")), "Expected Contra_Launcher.exe to exist");
+ Assert.True(File.Exists(Path.Combine(_stagingDirectory, "Data", "INI", "GameData.ini")), "Expected Data/INI/GameData.ini to exist");
+ Assert.False(File.Exists(Path.Combine(_stagingDirectory, "ModUninstaller.exe")), "Uninstaller executable should not be extracted");
+ }
+
+ ///
+ public void Dispose()
+ {
+ if (Directory.Exists(_stagingDirectory))
+ {
+ Directory.Delete(_stagingDirectory, recursive: true);
+ }
+ }
+
+ private static ArchivePayloadProcessor CreateProcessor()
+ {
+ return new ArchivePayloadProcessor(new Mock>().Object);
+ }
+
+ private static byte[] CreateSyntheticSmartInstallMakerExecutable(
+ (string Name, byte[] Content, bool UseBzip2)[] files,
+ bool includeUninstallerEntry = true)
+ {
+ using var ms = new MemoryStream();
+
+ // 1. DOS Header (64 bytes)
+ var dosHeader = new byte[64];
+ dosHeader[0] = (byte)'M';
+ dosHeader[1] = (byte)'Z';
+ BitConverter.GetBytes(0x80).CopyTo(dosHeader, 0x3C); // e_lfanew = 0x80
+ ms.Write(dosHeader, 0, 64);
+
+ // Pad to 0x80 (128 bytes)
+ while (ms.Length < 0x80)
+ {
+ ms.WriteByte(0);
+ }
+
+ // 2. PE Header at 0x80
+ ms.Write([(byte)'P', (byte)'E', 0, 0]);
+ var coffHeader = new byte[20];
+ BitConverter.GetBytes((ushort)0x14C).CopyTo(coffHeader, 0);
+ BitConverter.GetBytes((ushort)1).CopyTo(coffHeader, 2);
+ BitConverter.GetBytes((ushort)0).CopyTo(coffHeader, 16);
+ BitConverter.GetBytes((ushort)0x102).CopyTo(coffHeader, 18);
+ ms.Write(coffHeader, 0, 20);
+
+ // Section header (40 bytes): Name=.text, VirtualSize=0x200, VirtualAddress=0x1000, SizeOfRawData=0x200, PointerToRawData=0x200
+ var secHeader = new byte[40];
+ System.Text.Encoding.ASCII.GetBytes(".text").CopyTo(secHeader, 0);
+ BitConverter.GetBytes(0x200).CopyTo(secHeader, 8);
+ BitConverter.GetBytes(0x1000).CopyTo(secHeader, 12);
+ BitConverter.GetBytes(0x200).CopyTo(secHeader, 16);
+ BitConverter.GetBytes(0x200).CopyTo(secHeader, 20);
+ ms.Write(secHeader, 0, 40);
+
+ // Pad to Raw End = 0x200 + 0x200 = 0x400 (1024 bytes)
+ while (ms.Length < 0x400)
+ {
+ ms.WriteByte(0);
+ }
+
+ // Overlay starts at 0x400 (1024)
+ var simSig = new byte[] { 0x77, 0x77, 0x67, 0x54, 0x29, 0x48, 0x35, 0x14 };
+ ms.Write(simSig, 0, simSig.Length);
+
+ // Prepare compressed payloads
+ using var payloadMs = new MemoryStream();
+ var uninstallerText = System.Text.Encoding.Latin1.GetBytes("UninstallerStubText");
+ payloadMs.Write(uninstallerText, 0, uninstallerText.Length);
+
+ var tableRecords = new List<(string Name, uint UncompSize, uint Offset, uint CompSize)>();
+
+ if (includeUninstallerEntry)
+ {
+ tableRecords.Add(("ModUninstaller.exe", 100, 0, (uint)uninstallerText.Length));
+ }
+
+ foreach (var (name, content, useBzip2) in files)
+ {
+ var offset = (uint)payloadMs.Length;
+ byte[] compressed;
+ if (useBzip2)
+ {
+ using var bzMs = new MemoryStream();
+ using (var bz = SharpCompress.Compressors.BZip2.BZip2Stream.Create(bzMs, SharpCompress.Compressors.CompressionMode.Compress, decompressConcatenated: false, leaveOpen: false))
+ {
+ bz.Write(content, 0, content.Length);
+ }
+
+ compressed = bzMs.ToArray();
+ }
+ else
+ {
+ using var defMs = new MemoryStream();
+ defMs.WriteByte(0x78);
+ defMs.WriteByte(0xDA);
+ using (var def = new DeflateStream(defMs, CompressionLevel.Optimal, leaveOpen: false))
+ {
+ def.Write(content, 0, content.Length);
+ }
+
+ compressed = defMs.ToArray();
+ }
+
+ payloadMs.Write(compressed, 0, compressed.Length);
+ tableRecords.Add((name, (uint)content.Length, offset, (uint)compressed.Length));
+ }
+
+ // Prepare table data
+ using var tableMs = new MemoryStream();
+ tableMs.Write(new byte[40]); // initial padding
+ foreach (var (name, uncomp, offset, comp) in tableRecords)
+ {
+ var recordHeader = new byte[40];
+ BitConverter.GetBytes(uncomp).CopyTo(recordHeader, 0);
+ BitConverter.GetBytes(offset).CopyTo(recordHeader, 4);
+ BitConverter.GetBytes(comp).CopyTo(recordHeader, 8);
+ tableMs.Write(recordHeader, 0, 40);
+
+ var nameBytes = System.Text.Encoding.Latin1.GetBytes(name + "\0");
+ tableMs.Write(nameBytes, 0, nameBytes.Length);
+ tableMs.Write(new byte[40]); // separator padding
+ }
+
+ var compressedTable = Array.Empty();
+ using (var defTableMs = new MemoryStream())
+ {
+ defTableMs.WriteByte(0x78);
+ defTableMs.WriteByte(0xDA);
+ using (var def = new DeflateStream(defTableMs, CompressionLevel.Optimal, leaveOpen: false))
+ {
+ var tableRaw = tableMs.ToArray();
+ def.Write(tableRaw, 0, tableRaw.Length);
+ }
+
+ compressedTable = defTableMs.ToArray();
+ }
+
+ // Block 0: Dummy Info Block
+ byte[] dummyData = [0x78, 0xDA, 0x01, 0x00, 0x00, 0xFF, 0xFF];
+ using var writer = new BinaryWriter(ms, System.Text.Encoding.UTF8, leaveOpen: true);
+ writer.Write((short)1);
+ writer.Write(dummyData.Length + 5);
+ writer.Write(0);
+ writer.Write((byte)1);
+ writer.Write(dummyData);
+
+ // Block 1: Table Block (second to last)
+ writer.Write((int)1);
+ writer.Write(compressedTable.Length + 5);
+ writer.Write(0);
+ writer.Write((byte)1);
+ writer.Write(compressedTable);
+
+ // Block 2: Payload Block (last)
+ var payloadBytes = payloadMs.ToArray();
+ writer.Write((int)2);
+ writer.Write(payloadBytes.Length + 5);
+ writer.Write(0);
+ writer.Write((byte)1);
+ writer.Write(payloadBytes);
+
+ return ms.ToArray();
+ }
+}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostDelivererTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostDelivererTests.cs
new file mode 100644
index 000000000..0fed22013
--- /dev/null
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostDelivererTests.cs
@@ -0,0 +1,362 @@
+using System;
+using System.IO;
+using System.IO.Compression;
+using System.Threading;
+using System.Threading.Tasks;
+using GenHub.Core.Constants;
+using GenHub.Core.Interfaces.Common;
+using GenHub.Core.Interfaces.GameInstallations;
+using GenHub.Core.Models.Common;
+using GenHub.Core.Models.Enums;
+using GenHub.Core.Models.Manifest;
+using GenHub.Core.Models.Results;
+using GenHub.Features.Content.Services.CommunityOutpost;
+using Microsoft.Extensions.Logging.Abstractions;
+using Moq;
+using Xunit;
+using ContentType = GenHub.Core.Models.Enums.ContentType;
+
+namespace GenHub.Tests.Core.Features.Content.CommunityOutpost;
+
+///
+/// Unit tests for .
+///
+public sealed class CommunityOutpostDelivererTests
+{
+ ///
+ /// Verifies that ValidateContentAsync succeeds when a manifest contains a valid archive file.
+ ///
+ /// A task that completes when the operation finishes.
+ [Fact]
+ public async Task ValidateContentAsync_ValidDatArchive_ReturnsSuccessAsync()
+ {
+ // Arrange
+ var downloadService = new Mock();
+ var converter = new CompressedImageToTgaConverter(NullLogger.Instance);
+ var deliverer = new CommunityOutpostDeliverer(
+ downloadService.Object,
+ converter,
+ NullLogger.Instance);
+
+ var manifest = new ContentManifest
+ {
+ Id = ManifestId.Create("1.0.communityoutpost.addon.hlen"),
+ Name = "Hotkeys Indicators",
+ ContentType = ContentType.Addon,
+ TargetGame = GameType.ZeroHour,
+ Publisher = new PublisherInfo { PublisherType = CommunityOutpostConstants.PublisherType },
+ Files =
+ [
+ new ManifestFile
+ {
+ RelativePath = "hlen.dat",
+ DownloadUrl = "https://legi.cc/gp2/f/hlen.dat",
+ },
+ ],
+ };
+
+ // Act
+ var result = await deliverer.ValidateContentAsync(manifest, CancellationToken.None);
+
+ // Assert
+ Assert.True(result.Success);
+ Assert.True(result.Data);
+ }
+
+ ///
+ /// Verifies that DeliverContentAsync falls back to the /gp2/f/ endpoint when the primary /patch/ URL fails.
+ ///
+ /// A task that completes when the operation finishes.
+ [Fact]
+ public async Task DeliverContentAsync_PatchUrlFailure_FallsBackToGp2FilesEndpointAsync()
+ {
+ // Arrange
+ var tempDirectory = Path.Combine(Path.GetTempPath(), "GenHubTests", Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(tempDirectory);
+
+ try
+ {
+ var downloadService = new Mock();
+ var converter = new CompressedImageToTgaConverter(NullLogger.Instance);
+ var deliverer = new CommunityOutpostDeliverer(
+ downloadService.Object,
+ converter,
+ NullLogger.Instance);
+
+ var manifest = new ContentManifest
+ {
+ Id = ManifestId.Create("1.0.communityoutpost.addon.gent"),
+ Name = "GenTool",
+ ContentType = ContentType.Addon,
+ TargetGame = GameType.ZeroHour,
+ Publisher = new PublisherInfo { PublisherType = CommunityOutpostConstants.PublisherType },
+ Metadata = new ContentMetadata { Tags = ["contentCode:gent"] },
+ Files =
+ [
+ new ManifestFile
+ {
+ RelativePath = "gent.zip",
+ DownloadUrl = "https://legi.cc/patch/gent.zip",
+ },
+ ],
+ };
+
+ // Create a small valid zip file for the fallback download
+ var validZipBytes = CreateDummyZipArchive();
+
+ downloadService
+ .Setup(d => d.DownloadFileAsync(
+ new Uri("https://legi.cc/patch/gent.zip"),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()))
+ .ReturnsAsync(DownloadResult.CreateFailure("404 Not Found"));
+
+ downloadService
+ .Setup(d => d.DownloadFileAsync(
+ new Uri("https://legi.cc/gp2/f/gent.dat"),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()))
+ .Callback?, CancellationToken>((_, dest, _, _, _) => File.WriteAllBytes(dest, validZipBytes))
+ .ReturnsAsync(DownloadResult.CreateSuccess("content.zip", validZipBytes.Length, TimeSpan.FromMilliseconds(100)));
+
+ // Act
+ var result = await deliverer.DeliverContentAsync(manifest, tempDirectory, null, CancellationToken.None);
+
+ // Assert
+ Assert.True(result.Success, result.FirstError);
+ downloadService.Verify(
+ d => d.DownloadFileAsync(
+ new Uri("https://legi.cc/gp2/f/gent.dat"),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()),
+ Times.Once);
+ }
+ finally
+ {
+ if (Directory.Exists(tempDirectory))
+ {
+ try
+ {
+ Directory.Delete(tempDirectory, recursive: true);
+ }
+ catch
+ {
+ }
+ }
+ }
+ }
+
+ ///
+ /// Verifies that when the primary download URL returns an HTML error page with HTTP 200,
+ /// DeliverContentAsync rejects the HTML and successfully falls back to a valid archive URL.
+ ///
+ /// A task that completes when the operation finishes.
+ [Fact]
+ public async Task DeliverContentAsync_HtmlResponseOnPrimaryUrl_RejectsHtmlAndFallsBackToArchiveAsync()
+ {
+ // Arrange
+ var tempDirectory = Path.Combine(Path.GetTempPath(), "GenHubTests", Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(tempDirectory);
+
+ try
+ {
+ var downloadService = new Mock();
+ var converter = new CompressedImageToTgaConverter(NullLogger.Instance);
+ var deliverer = new CommunityOutpostDeliverer(
+ downloadService.Object,
+ converter,
+ NullLogger.Instance);
+
+ var manifest = new ContentManifest
+ {
+ Id = ManifestId.Create("1.20260802.communityoutpost.gameclient.communitypatch"),
+ Name = "Community Patch",
+ ContentType = ContentType.GameClient,
+ TargetGame = GameType.ZeroHour,
+ Publisher = new PublisherInfo { PublisherType = CommunityOutpostConstants.PublisherType },
+ Metadata = new ContentMetadata { Tags = ["contentCode:community-patch"] },
+ Files =
+ [
+ new ManifestFile
+ {
+ RelativePath = "community-patch.zip",
+ DownloadUrl = "https://legi.cc/gp2/f/community-patch.zip",
+ },
+ ],
+ };
+
+ var validZipBytes = CreateDummyZipArchive();
+ var htmlErrorBytes = System.Text.Encoding.UTF8.GetBytes("404 Not Found");
+
+ // Primary URL writes HTML error body
+ downloadService
+ .Setup(d => d.DownloadFileAsync(
+ new Uri("https://legi.cc/gp2/f/community-patch.zip"),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()))
+ .Callback?, CancellationToken>((_, dest, _, _, _) => File.WriteAllBytes(dest, htmlErrorBytes))
+ .ReturnsAsync(DownloadResult.CreateSuccess("content.zip", htmlErrorBytes.Length, TimeSpan.FromMilliseconds(50)));
+
+ // Fallback GitHub URL writes valid zip archive
+ downloadService
+ .Setup(d => d.DownloadFileAsync(
+ It.Is(u => u.Host.Contains("github.com")),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()))
+ .Callback?, CancellationToken>((_, dest, _, _, _) => File.WriteAllBytes(dest, validZipBytes))
+ .ReturnsAsync(DownloadResult.CreateSuccess("content.zip", validZipBytes.Length, TimeSpan.FromMilliseconds(100)));
+
+ // Act
+ var result = await deliverer.DeliverContentAsync(manifest, tempDirectory, null, CancellationToken.None);
+
+ // Assert
+ Assert.True(result.Success, result.FirstError);
+ downloadService.Verify(
+ d => d.DownloadFileAsync(
+ It.Is(u => u.Host.Contains("github.com")),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()),
+ Times.Once);
+ }
+ finally
+ {
+ if (Directory.Exists(tempDirectory))
+ {
+ try
+ {
+ Directory.Delete(tempDirectory, recursive: true);
+ }
+ catch
+ {
+ }
+ }
+ }
+ }
+
+ ///
+ /// Verifies that when delivering content resolved from a generic catalog without explicit manifest dependencies,
+ /// DeliverContentAsync discovers and merges registry-defined AutoInstall dependencies (such as hlen for hleg).
+ ///
+ /// A task that completes when the operation finishes.
+ [Fact]
+ public async Task DeliverContentAsync_GenericCatalogHotkeysWithoutExplicitDependencies_ProcessesAndMergesIndicatorsDependencyAsync()
+ {
+ // Arrange
+ var tempDirectory = Path.Combine(Path.GetTempPath(), "GenHubTests", Guid.NewGuid().ToString("N"));
+ Directory.CreateDirectory(tempDirectory);
+
+ try
+ {
+ var downloadService = new Mock();
+ var converter = new CompressedImageToTgaConverter(NullLogger.Instance);
+ var deliverer = new CommunityOutpostDeliverer(
+ downloadService.Object,
+ converter,
+ NullLogger.Instance);
+
+ var manifest = new ContentManifest
+ {
+ Id = ManifestId.Create("1.20260701.communityoutpost.addon.hleg"),
+ Name = "Legionnaire's Hotkeys",
+ ContentType = ContentType.Addon,
+ TargetGame = GameType.ZeroHour,
+ Publisher = new PublisherInfo { PublisherType = CommunityOutpostConstants.PublisherType },
+ Metadata = new ContentMetadata { Tags = ["contentCode:hleg"] },
+ Dependencies = [],
+ Files =
+ [
+ new ManifestFile
+ {
+ RelativePath = "hleg.dat",
+ DownloadUrl = "https://legi.cc/gp2/f/hleg.dat",
+ },
+ ],
+ };
+
+ var validZipBytes = CreateDummyZipArchive();
+
+ downloadService
+ .Setup(d => d.DownloadFileAsync(
+ It.Is(u => u.ToString().Contains("hleg")),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()))
+ .Callback?, CancellationToken>((_, dest, _, _, _) => File.WriteAllBytes(dest, validZipBytes))
+ .ReturnsAsync(DownloadResult.CreateSuccess("hleg.dat", validZipBytes.Length, TimeSpan.FromMilliseconds(50)));
+
+ downloadService
+ .Setup(d => d.DownloadFileAsync(
+ It.Is(u => u.ToString().Contains("hlen")),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()))
+ .Callback?, CancellationToken>((_, dest, _, _, _) => File.WriteAllBytes(dest, validZipBytes))
+ .ReturnsAsync(DownloadResult.CreateSuccess("hlen.dat", validZipBytes.Length, TimeSpan.FromMilliseconds(50)));
+
+ downloadService
+ .Setup(d => d.DownloadFileAsync(
+ It.Is(u => u.ToString().Contains("gent")),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()))
+ .Callback?, CancellationToken>((_, dest, _, _, _) => File.WriteAllBytes(dest, validZipBytes))
+ .ReturnsAsync(DownloadResult.CreateSuccess("gent.dat", validZipBytes.Length, TimeSpan.FromMilliseconds(50)));
+
+ // Act
+ var result = await deliverer.DeliverContentAsync(manifest, tempDirectory, null, CancellationToken.None);
+
+ // Assert
+ Assert.True(result.Success, result.FirstError);
+ downloadService.Verify(
+ d => d.DownloadFileAsync(
+ It.Is(u => u.ToString().Contains("hlen.dat")),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny>(),
+ It.IsAny()),
+ Times.AtLeastOnce);
+ }
+ finally
+ {
+ if (Directory.Exists(tempDirectory))
+ {
+ try
+ {
+ Directory.Delete(tempDirectory, recursive: true);
+ }
+ catch
+ {
+ }
+ }
+ }
+ }
+
+ private static byte[] CreateDummyZipArchive()
+ {
+ using var memoryStream = new MemoryStream();
+ using (var archive = new ZipArchive(memoryStream, ZipArchiveMode.Create, true))
+ {
+ var entry = archive.CreateEntry("dummy.txt");
+ using var entryStream = entry.Open();
+ using var writer = new StreamWriter(entryStream);
+ writer.Write("test payload");
+ }
+
+ return memoryStream.ToArray();
+ }
+}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostDiscovererTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostDiscovererTests.cs
index 8a9fa81b4..82e726f9f 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostDiscovererTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostDiscovererTests.cs
@@ -10,6 +10,7 @@
using Moq;
using Moq.Protected;
using Xunit;
+using ContentType = GenHub.Core.Models.Enums.ContentType;
namespace GenHub.Tests.Core.Features.Content.CommunityOutpost;
@@ -67,7 +68,7 @@ public void CommunityPatchIdFormat_SpecificationDocumentation()
// Arrange
var versionDate = "2026-01-28";
var providerName = CommunityOutpostConstants.PublisherType;
- var expectedId = $"1.{versionDate.Replace("-", string.Empty)}.{providerName}.gameclient.community-patch";
+ var expectedId = CatalogManifestIdentity.CreateContentId(providerName, ContentType.GameClient, "community-patch", versionDate);
// Act
var segments = expectedId.Split('.');
@@ -78,7 +79,7 @@ public void CommunityPatchIdFormat_SpecificationDocumentation()
Assert.Equal("20260128", segments[1]); // user version (date)
Assert.Equal("communityoutpost", segments[2]); // publisher
Assert.Equal("gameclient", segments[3]); // content type
- Assert.Equal("community-patch", segments[4]); // content name
+ Assert.Equal("communitypatch", segments[4]); // content name
}
///
@@ -137,13 +138,13 @@ public async Task DiscoverAsync_GeneratesCorrectIdForCommunityPatchAsync()
// Assert
Assert.True(result.Success, $"Discovery failed: {result.FirstError}");
Assert.NotEmpty(result.Data.Items);
- var patch = result.Data.Items.FirstOrDefault(i => i.Id.Contains("community-patch"));
+ var patch = result.Data.Items.FirstOrDefault(i => i.Id.Contains("communitypatch") || i.Id.Contains("community-patch"));
Assert.NotNull(patch);
var idParts = patch.Id.Split('.');
Assert.Equal(5, idParts.Length);
Assert.Equal("1", idParts[0]);
Assert.Equal("communityoutpost", idParts[2]);
Assert.Equal("gameclient", idParts[3]);
- Assert.Equal("community-patch", idParts[4]);
+ Assert.Equal("communitypatch", idParts[4]);
}
}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostManifestFactoryTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostManifestFactoryTests.cs
index b976ece3e..c3d836dd0 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostManifestFactoryTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostManifestFactoryTests.cs
@@ -1,4 +1,5 @@
using GenHub.Core.Interfaces.Common;
+using GenHub.Core.Interfaces.Content;
using GenHub.Core.Models.CommunityOutpost;
using GenHub.Core.Models.Enums;
using GenHub.Core.Models.Manifest;
@@ -22,6 +23,7 @@ public class CommunityOutpostManifestFactoryTests : IDisposable
{
private readonly Mock> _loggerMock;
private readonly Mock _hashProviderMock;
+ private readonly Mock _controlBarProcessorMock;
private readonly CommunityOutpostManifestFactory _factory;
private readonly string _tempDir;
@@ -32,11 +34,12 @@ public CommunityOutpostManifestFactoryTests()
{
_loggerMock = new Mock>();
_hashProviderMock = new Mock();
+ _controlBarProcessorMock = new Mock();
_hashProviderMock.Setup(x => x.ComputeFileHashAsync(It.IsAny(), It.IsAny()))
.ReturnsAsync("abc123hash");
- _factory = new CommunityOutpostManifestFactory(_loggerMock.Object, _hashProviderMock.Object, null!);
+ _factory = new CommunityOutpostManifestFactory(_loggerMock.Object, _hashProviderMock.Object, _controlBarProcessorMock.Object);
_tempDir = Path.Combine(Path.GetTempPath(), "GenHubTest_" + Guid.NewGuid().ToString("N"));
Directory.CreateDirectory(_tempDir);
}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostResolverTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostResolverTests.cs
index 5b223f092..a2baa30cc 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostResolverTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/CommunityOutpostResolverTests.cs
@@ -1,5 +1,6 @@
using System;
using System.Collections.Generic;
+using System.Threading;
using System.Threading.Tasks;
using GenHub.Core.Constants;
using GenHub.Core.Interfaces.Manifest;
@@ -17,9 +18,9 @@
namespace GenHub.Tests.Core.Features.Content.CommunityOutpost;
///
-/// Tests for CommunityOutpostResolver to verify manifest generation and ingestion gate compatibility.
+/// Unit tests for .
///
-public class CommunityOutpostResolverTests
+public sealed class CommunityOutpostResolverTests
{
private readonly Mock _providerLoaderMock;
@@ -30,7 +31,7 @@ public CommunityOutpostResolverTests()
{
_providerLoaderMock = new Mock();
- var providerDefinition = new ProviderDefinition
+ var provider = new ProviderDefinition
{
ProviderId = CommunityOutpostConstants.PublisherId,
PublisherType = CommunityOutpostConstants.PublisherType,
@@ -42,8 +43,148 @@ public CommunityOutpostResolverTests()
};
_providerLoaderMock
- .Setup(l => l.GetProvider(CommunityOutpostConstants.PublisherId))
- .Returns(providerDefinition);
+ .Setup(p => p.GetProvider(CommunityOutpostConstants.PublisherId))
+ .Returns(provider);
+ }
+
+ ///
+ /// Verifies that resolving a variant item populates SelectedVariantId and variant tags.
+ ///
+ /// A task representing the asynchronous operation.
+ [Fact]
+ public async Task ResolveAsync_WithVariantSearchResult_PopulatesSelectedVariantIdAndTagsAsync()
+ {
+ // Arrange
+ var searchResult = new ContentSearchResult
+ {
+ Id = "1.0.communityoutpost.addon.cbpr-1080p",
+ Name = "Control Bar Pro (ExiLe) - 1080p (Recommended)",
+ ProviderName = "communityoutpost",
+ ContentType = ContentType.Addon,
+ TargetGame = GameType.ZeroHour,
+ SourceUrl = "https://example.com/cbpr.dat",
+ };
+ searchResult.ResolverMetadata["contentCode"] = "cbpr";
+ searchResult.ResolverMetadata["selectedVariant"] = "1080p";
+
+ var builtManifest = new ContentManifest
+ {
+ Id = ManifestId.Create("1.0.communityoutpost.addon.cbpr1080p"),
+ Name = "Control Bar Pro (ExiLe)",
+ ContentType = ContentType.Addon,
+ TargetGame = GameType.ZeroHour,
+ Files = [new ManifestFile { RelativePath = "cbpr.dat" }],
+ };
+
+ var builderMock = CreateBuilderMock(builtManifest);
+ var resolver = new CommunityOutpostResolver(
+ () => builderMock.Object,
+ _providerLoaderMock.Object,
+ NullLogger.Instance);
+
+ // Act
+ var result = await resolver.ResolveAsync(searchResult, CancellationToken.None);
+
+ // Assert
+ Assert.True(result.Success);
+ var manifest = result.Data;
+ Assert.NotNull(manifest);
+ Assert.Equal("1080p", manifest.Metadata?.SelectedVariantId);
+ Assert.Contains(manifest.Metadata?.Tags ?? [], t => t == "requestedVariant:1080p");
+ Assert.Contains(manifest.Metadata?.Tags ?? [], t => t == "selectedVariant:1080p");
+ Assert.Contains(manifest.Metadata?.Tags ?? [], t => t == "contentCode:cbpr");
+ }
+
+ ///
+ /// Verifies that resolving an item with catalog version 0 generates version 0 manifest.
+ ///
+ /// A task representing the asynchronous operation.
+ [Fact]
+ public async Task ResolveAsync_WithVersionZeroId_PreservesVersionZeroAsync()
+ {
+ // Arrange
+ var searchResult = new ContentSearchResult
+ {
+ Id = "1.0.communityoutpost.addon.gent",
+ Name = "GenTool",
+ ProviderName = "communityoutpost",
+ ContentType = ContentType.Addon,
+ TargetGame = GameType.ZeroHour,
+ Version = "1.0",
+ SourceUrl = "https://example.com/gent.zip",
+ };
+ searchResult.ResolverMetadata["contentCode"] = "gent";
+
+ var builtManifest = new ContentManifest
+ {
+ Id = ManifestId.Create("1.0.communityoutpost.addon.gent"),
+ Name = "GenTool",
+ ContentType = ContentType.Addon,
+ TargetGame = GameType.ZeroHour,
+ Files = [new ManifestFile { RelativePath = "gent.zip" }],
+ };
+
+ var builderMock = CreateBuilderMock(builtManifest);
+ var resolver = new CommunityOutpostResolver(
+ () => builderMock.Object,
+ _providerLoaderMock.Object,
+ NullLogger.Instance);
+
+ // Act
+ var result = await resolver.ResolveAsync(searchResult, CancellationToken.None);
+
+ // Assert
+ Assert.True(result.Success);
+ var manifest = result.Data;
+ Assert.NotNull(manifest);
+ Assert.StartsWith("1.0.communityoutpost.addon.", manifest.Id.Value);
+ }
+
+ ///
+ /// Verifies that resolving an item with null or empty version falls back to a valid default version.
+ ///
+ /// A task representing the asynchronous operation.
+ [Fact]
+ public async Task ResolveAsync_WithNullVersion_SetsValidDefaultVersionAsync()
+ {
+ // Arrange
+ var searchResult = new ContentSearchResult
+ {
+ Id = "file:https://example.com/cbpx.dat",
+ Name = "Control Bar Pro (Xezon) - 1080p (Recommended)",
+ ProviderName = "communityoutpost",
+ ContentType = ContentType.Addon,
+ TargetGame = GameType.ZeroHour,
+ Version = string.Empty,
+ SourceUrl = "https://example.com/cbpx.dat",
+ };
+ searchResult.ResolverMetadata["contentCode"] = "cbpx";
+ searchResult.ResolverMetadata["selectedVariant"] = "1080p";
+
+ var builtManifest = new ContentManifest
+ {
+ Id = ManifestId.Create("1.0.communityoutpost.addon.cbpx1080p"),
+ Name = "Control Bar Pro (Xezon)",
+ ContentType = ContentType.Addon,
+ TargetGame = GameType.ZeroHour,
+ Files = [new ManifestFile { RelativePath = "cbpx.dat" }],
+ };
+
+ var builderMock = CreateBuilderMock(builtManifest);
+ var resolver = new CommunityOutpostResolver(
+ () => builderMock.Object,
+ _providerLoaderMock.Object,
+ NullLogger.Instance);
+
+ // Act
+ var result = await resolver.ResolveAsync(searchResult, CancellationToken.None);
+
+ // Assert
+ Assert.True(result.Success);
+ var manifest = result.Data;
+ Assert.NotNull(manifest);
+ Assert.False(string.IsNullOrWhiteSpace(manifest.Version));
+ Assert.Equal("1.0", manifest.Version);
}
///
@@ -92,7 +233,7 @@ public async Task ResolveAsync_CommunityPatch_GeneratesManifestAcceptedByIngesti
Times.Once);
var manifest = result.Data;
- Assert.Equal(ManifestConstants.DefaultManifestVersion, manifest.ManifestVersion);
+ Assert.Equal(ManifestConstants.DefaultManifestVersion, manifest.SchemaVersion);
Assert.Equal("27-08-2026", manifest.Version);
Assert.Equal(ContentType.GameClient, manifest.ContentType);
Assert.Equal(GameType.ZeroHour, manifest.TargetGame);
@@ -163,7 +304,7 @@ public async Task ResolveAsync_BaseGamePatch_GeneratesManifestAcceptedByIngestio
Times.Once);
var manifest = result.Data;
- Assert.Equal(ManifestConstants.DefaultManifestVersion, manifest.ManifestVersion);
+ Assert.Equal(ManifestConstants.DefaultManifestVersion, manifest.SchemaVersion);
Assert.Equal(version, manifest.Version);
var accepted = ManifestIngestionGate.TryAccept(manifest, out var rejectionReason);
@@ -210,13 +351,52 @@ public async Task ResolveAsync_AddonContent_GeneratesManifestAcceptedByIngestion
Assert.NotNull(result.Data);
var manifest = result.Data;
- Assert.Equal(ManifestConstants.DefaultManifestVersion, manifest.ManifestVersion);
+ Assert.Equal(ManifestConstants.DefaultManifestVersion, manifest.SchemaVersion);
var accepted = ManifestIngestionGate.TryAccept(manifest, out var rejectionReason);
Assert.True(accepted, $"Manifest should be accepted by ManifestIngestionGate, but was rejected with: {rejectionReason}");
Assert.Null(rejectionReason);
}
+ private static Mock CreateBuilderMock(ContentManifest builtManifest)
+ {
+ var builderMock = new Mock();
+ builderMock.Setup(b => b.WithBasicInfo(It.IsAny(), It.IsAny(), It.IsAny()))
+ .Returns(builderMock.Object);
+ builderMock.Setup(b => b.WithContentType(It.IsAny(), It.IsAny()))
+ .Returns(builderMock.Object);
+ builderMock.Setup(b => b.WithName(It.IsAny()))
+ .Returns(builderMock.Object);
+ builderMock.Setup(b => b.WithId(It.IsAny()))
+ .Returns(builderMock.Object);
+ builderMock.Setup(b => b.WithPublisher(
+ It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()))
+ .Returns(builderMock.Object);
+ builderMock.Setup(b => b.WithMetadata(
+ It.IsAny(), It.IsAny?>(), It.IsAny(), It.IsAny?>(), It.IsAny()))
+ .Returns(builderMock.Object);
+ builderMock.Setup(b => b.WithInstallationInstructions(It.IsAny()))
+ .Returns(builderMock.Object);
+ builderMock.Setup(b => b.AddRemoteFileAsync(
+ It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny()))
+ .ReturnsAsync(builderMock.Object);
+ builderMock.Setup(b => b.AddDependency(
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny(),
+ It.IsAny?>(),
+ It.IsAny(),
+ It.IsAny?>(),
+ It.IsAny?>()))
+ .Returns(builderMock.Object);
+ builderMock.Setup(b => b.Build()).Returns(builtManifest);
+
+ return builderMock;
+ }
+
private static Mock CreateBuilderMock(
ManifestId manifestId,
string name,
@@ -231,33 +411,9 @@ private static Mock CreateBuilderMock(
Version = version,
ContentType = contentType,
TargetGame = targetGame,
- ManifestVersion = ManifestConstants.DefaultManifestVersion,
+ SchemaVersion = ManifestConstants.DefaultManifestVersion,
};
- var builderMock = new Mock();
- builderMock.Setup(m => m.WithBasicInfo(It.IsAny(), It.IsAny(), It.IsAny())).Returns(builderMock.Object);
- builderMock.Setup(m => m.WithContentType(It.IsAny(), It.IsAny())).Returns(builderMock.Object);
- builderMock.Setup(m => m.WithPublisher(It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny(), It.IsAny())).Returns(builderMock.Object);
- builderMock.Setup(m => m.WithMetadata(It.IsAny(), It.IsAny?>(), It.IsAny(), It.IsAny?>(), It.IsAny())).Returns(builderMock.Object);
- builderMock.Setup(m => m.WithInstallationInstructions(It.IsAny())).Returns(builderMock.Object);
- builderMock.Setup(m => m.AddDependency(
- It.IsAny(),
- It.IsAny(),
- It.IsAny(),
- It.IsAny(),
- It.IsAny(),
- It.IsAny(),
- It.IsAny?>(),
- It.IsAny(),
- It.IsAny?>())).Returns(builderMock.Object);
- builderMock.Setup(m => m.AddRemoteFileAsync(
- It.IsAny(),
- It.IsAny(),
- It.IsAny(),
- It.IsAny(),
- It.IsAny())).ReturnsAsync(builderMock.Object);
- builderMock.Setup(m => m.Build()).Returns(manifest);
-
- return builderMock;
+ return CreateBuilderMock(manifest);
}
}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/GenPatcherDatCatalogParserTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/GenPatcherDatCatalogParserTests.cs
new file mode 100644
index 000000000..0d97b5f7c
--- /dev/null
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/GenPatcherDatCatalogParserTests.cs
@@ -0,0 +1,51 @@
+using System.Linq;
+using System.Threading.Tasks;
+using GenHub.Core.Models.Providers;
+using GenHub.Features.Content.Services.CommunityOutpost;
+using Microsoft.Extensions.Logging.Abstractions;
+using Xunit;
+
+namespace GenHub.Tests.Core.Features.Content.CommunityOutpost;
+
+///
+/// Tests for .
+///
+public class GenPatcherDatCatalogParserTests
+{
+ ///
+ /// Verifies that ParseAsync populates variants for Control Bar Pro metadata.
+ ///
+ /// A representing the asynchronous operation.
+ [Fact]
+ public async Task ParseAsync_PopulatesVariantsForControlBarProAsync()
+ {
+ // arrange
+ var parser = new GenPatcherDatCatalogParser(NullLogger.Instance);
+ var catalogContent = "2.13 ;;\r\ncbpr 005000000 Mirror1 https://example.com/cbpr.zip";
+ var provider = new ProviderDefinition
+ {
+ ProviderId = "communityoutpost",
+ PublisherType = "communityoutpost",
+ DisplayName = "Community Outpost",
+ };
+
+ // act
+ var result = await parser.ParseAsync(catalogContent, provider);
+
+ // assert
+ Assert.True(result.Success);
+ Assert.NotNull(result.Data);
+ var items = result.Data.ToList();
+ Assert.Single(items);
+
+ var item = items[0];
+ Assert.Equal("communityoutpost.addon.cbpr", item.VariantGroupId);
+ Assert.Equal("Control Bar Pro (ExiLe)", item.VariantFamilyName);
+ Assert.NotNull(item.Variants);
+ Assert.Equal(5, item.Variants.Count);
+
+ var firstVariant = item.Variants.First(v => v.Id == "1080p");
+ Assert.True(firstVariant.IsDefault);
+ Assert.Equal("1.0.communityoutpost.addon.cbpr-1080p", firstVariant.ManifestId);
+ }
+}
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/GenPatcherDependencyBuilderTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/GenPatcherDependencyBuilderTests.cs
index 165e2c1f1..49efd1014 100644
--- a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/GenPatcherDependencyBuilderTests.cs
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/CommunityOutpost/GenPatcherDependencyBuilderTests.cs
@@ -194,6 +194,26 @@ public void GetDependencies_Hotkeys_RequiresIndicatorsPack(string contentCode)
Assert.Contains(dependencies, d => d.Id.Value.EndsWith(".hlen") && d.DependencyType == ContentType.Addon);
}
+ ///
+ /// Verifies that Legionnaire's Hotkeys automatically reconciles its GenTool runtime requirement.
+ ///
+ [Fact]
+ public void GetDependencies_LegionnairesHotkeys_AutoInstallsGenTool()
+ {
+ // Arrange
+ var metadata = GenPatcherContentRegistry.GetMetadata("hleg");
+
+ // Act
+ var dependencies = GenPatcherDependencyBuilder.GetDependencies("hleg", metadata);
+
+ // Assert
+ Assert.Contains(dependencies, dependency =>
+ dependency.Id.Value.EndsWith(".gent", StringComparison.OrdinalIgnoreCase) &&
+ dependency.DependencyType == ContentType.Addon &&
+ dependency.InstallBehavior == DependencyInstallBehavior.AutoInstall &&
+ !dependency.IsOptional);
+ }
+
///
/// Verifies that control bars are marked as exclusive (conflict with each other).
///
diff --git a/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/ContentDiscoverers/AODMapsDiscovererTests.cs b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/ContentDiscoverers/AODMapsDiscovererTests.cs
new file mode 100644
index 000000000..7a69ab71f
--- /dev/null
+++ b/GenHub/GenHub.Tests/GenHub.Tests.Core/Features/Content/ContentDiscoverers/AODMapsDiscovererTests.cs
@@ -0,0 +1,253 @@
+using System;
+using System.Collections.Generic;
+using System.Net;
+using System.Net.Http;
+using System.Threading;
+using System.Threading.Tasks;
+using GenHub.Core.Constants;
+using GenHub.Core.Models.Content;
+using GenHub.Features.Content.Services.ContentDiscoverers;
+using Microsoft.Extensions.Logging;
+using Moq;
+using Xunit;
+
+namespace GenHub.Tests.Core.Features.Content.ContentDiscoverers;
+
+///
+/// Regression tests for AODMaps discovery metadata displayed by download cards.
+///
+public sealed class AODMapsDiscovererTests
+{
+ ///
+ /// Verifies gallery thumbnails resolve relative to their AOD category page and player metadata is retained.
+ ///
+ /// A task that represents the asynchronous test.
+ [Fact]
+ public async Task DiscoverAsync_AoaGalleryMap_UsesCategoryRelativeThumbnailAndPlayerBadgeMetadataAsync()
+ {
+ var result = await DiscoverAsync(
+ CreateGalleryHtml(includeImage: true, downloadId: "4P_1_1"),
+ new ContentSearchQuery
+ {
+ AODMapsCategory = AODMapsConstants.CategoryAoa,
+ Take = 10,
+ });
+
+ var item = Assert.Single(result.Data!.Items);
+ Assert.Equal("https://aodmaps.com/AOA/preview.png", item.IconUrl);
+ Assert.Equal(string.Empty, item.Version);
+ Assert.Equal("4", item.ResolverMetadata[AODMapsConstants.PlayerCountMetadataKey]);
+ Assert.Equal(AODMapsConstants.CategoryAoa, item.ResolverMetadata[AODMapsConstants.CategoryMetadataKey]);
+ Assert.Contains("4 Players", item.Tags);
+ Assert.Contains(AODMapsConstants.CategoryAoa, item.Tags);
+ Assert.Equal("Community Art of Attack map for 4 players.", item.Description);
+ }
+
+ ///
+ /// Verifies gallery maps with author and special AI/rule notes produce rich metadata and tags.
+ ///
+ /// A task that represents the asynchronous test.
+ [Fact]
+ public async Task DiscoverAsync_GalleryMapWithAuthorAndNotes_ExtractsAuthorAndRichDescriptionAsync()
+ {
+ var html = """
+
+