// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Formats.Tar;
using System.IO.Compression;
using System.Runtime.Versioning;
using Aspire.SelectTests;
using Aspire.Tools.CreateLayout;
using Aspire.TestUtilities;
using Xunit;
namespace Infrastructure.Tests;
public sealed class TrayBundleTests(ITestOutputHelper output)
{
[Theory]
[InlineData("win-x64", "")]
[InlineData("win-x64", " ")]
[InlineData("win-arm64", "")]
[InlineData("win-arm64", " ")]
[InlineData("osx-x64", "")]
[InlineData("osx-x64", " ")]
[InlineData("osx-arm64", "")]
[InlineData("osx-arm64", " ")]
[InlineData("linux-x64", "")]
[InlineData("linux-x64", " ")]
[InlineData("linux-arm64", "")]
[InlineData("linux-arm64", " ")]
public void DesktopLayoutsRejectEmptyTrayDirectory(string rid, string directory)
{
using var workspace = TemporaryWorkspace.Create(output);
using var builder = new LayoutBuilder(workspace.Path, workspace.Path, rid, "Debug", "test", false,
trayDirectory: directory, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
var error = Assert.Throws<InvalidOperationException>(builder.CopyTray);
Assert.Equal($"The {rid} bundle requires --tray-dir pointing to the prepared native tray directory (.app directory on macOS).", error.Message);
Assert.Empty(Directory.EnumerateFileSystemEntries(workspace.Path));
}
[Theory]
[InlineData("linux-x64")]
[InlineData("linux-arm64")]
public void LinuxLayoutsRequireExplicitNativePayload(string rid)
{
using var workspace = TemporaryWorkspace.Create(output);
using var builder = new LayoutBuilder(workspace.Path, workspace.Path, rid, "Debug", "test", false,
trayDirectory: null, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
Assert.Equal($"The {rid} bundle requires --tray-dir pointing to the prepared native tray directory (.app directory on macOS).",
Assert.Throws<InvalidOperationException>(builder.CopyTray).Message);
}
[Theory]
[InlineData("linux-x64")]
[InlineData("linux-arm64")]
[UnsupportedOSPlatform("windows")]
public async Task LinuxPayloadCopyAndArchivePreserveOnlyNativeRuntimeFiles(string rid)
{
Assert.SkipWhen(OperatingSystem.IsWindows(), "Linux bundles preserve Unix modes.");
using var workspace = TemporaryWorkspace.Create(output);
var source = Path.Combine(workspace.Path, "publish");
LinuxTrayTestPayload.Create(source, rid);
File.WriteAllText(Path.Combine(source, "aspire-tray.dbg"), "symbols");
var layout = Path.Combine(workspace.Path, rid);
using var builder = new LayoutBuilder(layout, workspace.Path, rid, "Debug", "test", false,
trayDirectory: source, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
builder.CopyTray();
var archivePath = await builder.CreateArchiveAsync();
await using var archive = File.OpenRead(archivePath);
await using var gzip = new GZipStream(archive, CompressionMode.Decompress);
await using var tar = new TarReader(gzip);
List<string> names = [];
while (await tar.GetNextEntryAsync() is { } entry)
{
if (entry.EntryType is not (TarEntryType.RegularFile or TarEntryType.V7RegularFile))
{
continue;
}
names.Add(entry.Name);
var original = Path.Combine(source, Path.GetFileName(entry.Name));
Assert.Equal(File.GetUnixFileMode(original), entry.Mode);
using var bytes = new MemoryStream();
await entry.DataStream!.CopyToAsync(bytes);
Assert.Equal(File.ReadAllBytes(original), bytes.ToArray());
}
Assert.Equal(new[] { $"{rid}/tray/Aspire.png", $"{rid}/tray/aspire-tray" }.Order(), names.Order());
}
[Theory]
[InlineData("linux-musl-x64")]
public void MuslLayoutsDoNotPackageTray(string rid)
{
using var workspace = TemporaryWorkspace.Create(output);
using var builder = new LayoutBuilder(workspace.Path, workspace.Path, rid, "Debug", "test", false,
trayDirectory: "missing-tray", dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
builder.CopyTray();
Assert.Empty(Directory.EnumerateFileSystemEntries(workspace.Path));
}
[Theory]
[InlineData("osx-arm64")]
[InlineData("osx-x64")]
public void MacLayoutRequiresExplicitTrayInput(string rid)
{
using var workspace = TemporaryWorkspace.Create(output);
using var builder = new LayoutBuilder(workspace.Path, workspace.Path, rid, "Debug", "test", false,
trayDirectory: null, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
var error = Assert.Throws<InvalidOperationException>(builder.CopyTray);
Assert.Equal($"The {rid} bundle requires --tray-dir pointing to the prepared native tray directory (.app directory on macOS).", error.Message);
}
[Theory]
[InlineData("Contents/MacOS/aspire-tray")]
[InlineData("Contents/Info.plist")]
[InlineData("Contents/Resources/Aspire.icns")]
[InlineData("Contents/_CodeSignature/CodeResources")]
public void MacLayoutRejectsIncompleteTray(string missingFile)
{
using var workspace = TemporaryWorkspace.Create(output);
var source = MacTrayTestPayload.Create(workspace.Path);
File.Delete(Path.Combine(source, missingFile));
using var builder = new LayoutBuilder(Path.Combine(workspace.Path, "layout"), workspace.Path, "osx-arm64", "Debug", "test", false,
trayDirectory: source, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
var error = Assert.Throws<InvalidOperationException>(builder.CopyTray);
Assert.Contains(Path.Combine(source, missingFile), error.Message);
}
[Fact]
[UnsupportedOSPlatform("windows")]
public void MacLayoutRejectsNonExecutableTray()
{
Assert.SkipWhen(OperatingSystem.IsWindows(), "Unix executable mode check.");
using var workspace = TemporaryWorkspace.Create(output);
var source = MacTrayTestPayload.Create(workspace.Path);
File.SetUnixFileMode(Path.Combine(source, "Contents/MacOS/aspire-tray"), UnixFileMode.UserRead);
using var builder = new LayoutBuilder(Path.Combine(workspace.Path, "layout"), workspace.Path, "osx-arm64", "Debug", "test", false,
trayDirectory: source, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
var error = Assert.Throws<InvalidOperationException>(builder.CopyTray);
Assert.Contains("not executable", error.Message);
}
[Fact]
[UnsupportedOSPlatform("windows")]
public async Task AppResourcesSignaturesAndExecutableModesSurviveCopyAndArchive()
{
Assert.SkipWhen(OperatingSystem.IsWindows(), "macOS bundles are assembled on Unix.");
using var workspace = TemporaryWorkspace.Create(output);
var source = MacTrayTestPayload.Create(workspace.Path);
var layout = Path.Combine(workspace.Path, "osx-arm64");
var destination = Path.Combine(layout, "tray", "Aspire Tray.app");
using var builder = new LayoutBuilder(layout, workspace.Path, "osx-arm64", "Debug", "test", false,
trayDirectory: source, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
builder.CopyTray();
var expectedFiles = Directory.GetFiles(source, "*", SearchOption.AllDirectories)
.Select(file => Path.GetRelativePath(source, file)).Order().ToArray();
Assert.Equal(expectedFiles, Directory.GetFiles(destination, "*", SearchOption.AllDirectories)
.Select(file => Path.GetRelativePath(destination, file)).Order().ToArray());
foreach (var file in expectedFiles)
{
Assert.Equal(File.ReadAllBytes(Path.Combine(source, file)), File.ReadAllBytes(Path.Combine(destination, file)));
Assert.Equal(File.GetUnixFileMode(Path.Combine(source, file)), File.GetUnixFileMode(Path.Combine(destination, file)));
}
var archivePath = await builder.CreateArchiveAsync();
await using var archive = File.OpenRead(archivePath);
await using var gzip = new GZipStream(archive, CompressionMode.Decompress);
await using var tar = new TarReader(gzip);
var archivedFiles = new List<string>();
while (await tar.GetNextEntryAsync() is { } entry)
{
if (entry.EntryType is not (TarEntryType.RegularFile or TarEntryType.V7RegularFile))
{
continue;
}
const string prefix = "osx-arm64/tray/Aspire Tray.app/";
Assert.StartsWith(prefix, entry.Name);
var relativePath = entry.Name[prefix.Length..];
archivedFiles.Add(relativePath);
Assert.Equal(File.GetUnixFileMode(Path.Combine(source, relativePath)), entry.Mode);
using var content = new MemoryStream();
await entry.DataStream!.CopyToAsync(content);
Assert.Equal(File.ReadAllBytes(Path.Combine(source, relativePath)), content.ToArray());
}
Assert.Equal(expectedFiles, archivedFiles.Order());
}
[Fact]
[RequiresTools(["pwsh", "ditto"])]
[SupportedOSPlatform("macos")]
public async Task MacSigningTransportContainsAppDirectoryAndPreservesExecutableModes()
{
Assert.SkipUnless(OperatingSystem.IsMacOS(), "macOS signing transport uses ditto.");
using var workspace = TemporaryWorkspace.Create(output);
var source = MacTrayTestPayload.Create(workspace.Path);
var archivePath = Path.Combine(workspace.Path, "signing", "AspireTray.zip");
var scriptPath = Path.Combine(workspace.Path, "prepare-signing.ps1");
File.WriteAllText(scriptPath, """
param([string]$RepositoryRoot, [string]$AppPath, [string]$ArchivePath)
& "$RepositoryRoot/dotnet.sh" msbuild "$RepositoryRoot/src/Aspire.Tray/Mac/Aspire.Tray.Mac.csproj" `
/t:CreateTrayAppSigningArchive /p:RuntimeIdentifier=osx-arm64 `
"/p:TrayAppPath=$AppPath" "/p:TraySigningArchive=$ArchivePath" /nologo
exit $LASTEXITCODE
""");
using var command = new PowerShellCommand(scriptPath, output)
.WithWorkingDirectory(RepoRoot.Path)
.WithTimeout(TimeSpan.FromMinutes(2));
var result = await command.ExecuteAsync(
"-RepositoryRoot", $"\"{RepoRoot.Path}\"",
"-AppPath", $"\"{source}\"",
"-ArchivePath", $"\"{archivePath}\"");
result.EnsureSuccessful();
using var archive = ZipFile.OpenRead(archivePath);
var files = archive.Entries.Where(entry => entry.Name.Length > 0 && !entry.FullName.StartsWith("__MACOSX/", StringComparison.Ordinal)).ToArray();
var expectedFiles = Directory.GetFiles(source, "*", SearchOption.AllDirectories)
.Select(file => $"{Path.GetFileName(source)}/{Path.GetRelativePath(source, file)}").Order().ToArray();
Assert.Equal(expectedFiles, files.Select(entry => entry.FullName).Order());
foreach (var entry in files)
{
var file = Path.Combine(Path.GetDirectoryName(source)!, entry.FullName);
using var content = new MemoryStream();
using var entryStream = entry.Open();
await entryStream.CopyToAsync(content);
Assert.Equal(File.ReadAllBytes(file), content.ToArray());
Assert.Equal(File.GetUnixFileMode(file), (UnixFileMode)((entry.ExternalAttributes >> 16) & 0x1FF));
}
}
[Theory]
[InlineData("Aspire.Tray.Mac", true)]
[InlineData("Aspire.Tray.Windows", true)]
[InlineData("Aspire.Tray.Linux", true)]
public void NativeTrayChangesSelectSharedAndPackagingTests(string project, bool bundled)
{
var selector = new TestSelector(
Path.Combine(RepoRoot.Path, "eng/github-ci/test-trigger-map.yml"),
new HashSet<string>(["Aspire.Tray.Tests", "Infrastructure.Tests", "Aspire.Cli.EndToEnd.Tests"], StringComparer.Ordinal),
new HashSet<string>(StringComparer.Ordinal),
affectedTestProjectNames: new HashSet<string>(StringComparer.Ordinal));
var result = selector.Select([], [project], new SelectorOptions());
Assert.False(result.SelectsAll);
Assert.Equal(bundled
? ["Aspire.Cli.EndToEnd.Tests", "Aspire.Tray.Tests", "Infrastructure.Tests"]
: new[] { "Aspire.Tray.Tests", "Infrastructure.Tests" },
result.TestProjects.Order(StringComparer.Ordinal));
Assert.Equal(bundled
? ["job:cli-starter-validation", "job:extension-e2e", "job:homebrew-installer", "job:winget-installer"]
: Array.Empty<string>(),
result.Jobs.Order(StringComparer.Ordinal));
}
[Theory]
[InlineData("win-x64")]
[InlineData("win-arm64")]
public async Task WindowsLayoutCopiesOnlyNativePayloadAndPreservesArchiveBytes(string rid)
{
using var workspace = TemporaryWorkspace.Create(output);
var source = Path.Combine(workspace.Path, "publish with spaces");
WindowsTrayTestPayload.Create(source, rid);
File.WriteAllText(Path.Combine(source, "smoke.stdout.log"), "not runtime content");
var layout = Path.Combine(workspace.Path, rid);
using var builder = new LayoutBuilder(layout, workspace.Path, rid, "Debug", "test", false,
trayDirectory: source, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
builder.CopyTray();
var archivePath = await builder.CreateArchiveAsync();
await using var archive = File.OpenRead(archivePath);
await using var gzip = new GZipStream(archive, CompressionMode.Decompress);
await using var tar = new TarReader(gzip);
var files = new List<string>();
while (await tar.GetNextEntryAsync() is { } entry)
{
if (entry.EntryType is not (TarEntryType.RegularFile or TarEntryType.V7RegularFile))
{
continue;
}
files.Add(entry.Name);
using var content = new MemoryStream();
await entry.DataStream!.CopyToAsync(content);
Assert.Equal(File.ReadAllBytes(Path.Combine(source, Path.GetFileName(entry.Name))), content.ToArray());
}
Assert.Equal(new[] { $"{rid}/tray/Aspire.ico", $"{rid}/tray/aspire-tray.exe" }.Order(), files.Order());
}
[Theory]
[InlineData("missing-input")]
[InlineData("missing-icon")]
[InlineData("missing-executable")]
[InlineData("wrong-rid")]
[InlineData("unsupported-rid")]
[InlineData("managed")]
public void WindowsLayoutRejectsInvalidPublishOutput(string scenario)
{
using var workspace = TemporaryWorkspace.Create(output);
var source = Path.Combine(workspace.Path, "publish");
WindowsTrayTestPayload.Create(source, scenario == "wrong-rid" ? "win-arm64" : "win-x64");
if (scenario == "missing-icon")
{
File.Delete(Path.Combine(source, "Aspire.ico"));
}
if (scenario == "missing-executable")
{
File.Delete(Path.Combine(source, "aspire-tray.exe"));
}
if (scenario == "managed")
{
File.Copy(typeof(TrayBundleTests).Assembly.Location, Path.Combine(source, "aspire-tray.exe"), overwrite: true);
}
using var builder = new LayoutBuilder(Path.Combine(workspace.Path, "layout"), workspace.Path,
scenario == "unsupported-rid" ? "win-x86" : "win-x64", "Debug", "test", false,
trayDirectory: scenario == "missing-input" ? null : source, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
if (scenario == "missing-input")
{
Assert.Equal("The win-x64 bundle requires --tray-dir pointing to the prepared native tray directory (.app directory on macOS).",
Assert.Throws<InvalidOperationException>(builder.CopyTray).Message);
}
else
{
Assert.Throws<InvalidDataException>(builder.CopyTray);
}
}
[Theory]
[RequiresTools(["pwsh", "tar"])]
[InlineData("win-x64", "valid", 0)]
[InlineData("win-arm64", "valid", 0)]
[InlineData("win-x64", "wrong-rid", 1)]
[InlineData("win-x64", "missing-icon", 1)]
[InlineData("win-x64", "changed-icon", 1)]
[InlineData("win-x64", "extra-file", 1)]
[InlineData("win-x64", "managed", 1)]
public async Task WindowsArchiveVerifierChecksActualPayload(string rid, string scenario, int expectedExitCode)
{
using var workspace = TemporaryWorkspace.Create(output);
var source = Path.Combine(workspace.Path, "source");
WindowsTrayTestPayload.Create(source, rid);
File.Copy(Path.Combine(RepoRoot.Path, "src/Shared/Aspire.ico"), Path.Combine(source, "Aspire.ico"), overwrite: true);
var layout = Path.Combine(workspace.Path, rid);
using var builder = new LayoutBuilder(layout, workspace.Path, rid, "Debug", "test", false,
trayDirectory: source, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
builder.CopyTray();
var tray = Path.Combine(layout, "tray");
switch (scenario)
{
case "wrong-rid":
WindowsTrayTestPayload.Create(tray, "win-arm64");
File.Copy(Path.Combine(source, "Aspire.ico"), Path.Combine(tray, "Aspire.ico"), overwrite: true);
break;
case "missing-icon":
File.Delete(Path.Combine(tray, "Aspire.ico"));
break;
case "changed-icon":
File.WriteAllText(Path.Combine(tray, "Aspire.ico"), "wrong icon");
break;
case "extra-file":
File.WriteAllText(Path.Combine(tray, "smoke.log"), "unexpected runtime content");
break;
case "managed":
File.Copy(typeof(TrayBundleTests).Assembly.Location, Path.Combine(tray, "aspire-tray.exe"), overwrite: true);
break;
}
var archive = await builder.CreateArchiveAsync();
using var command = new PowerShellCommand(Path.Combine(RepoRoot.Path, "tools/CreateLayout/verify-windows-tray-payload.ps1"), output)
.WithTimeout(TimeSpan.FromMinutes(1));
var result = await command.ExecuteAsync("-Archive", $"\"{archive}\"", "-Rid", rid, "-RequireSignature", "false");
result.EnsureExitCode(expectedExitCode);
if (expectedExitCode == 0)
{
Assert.Contains($"Verified {rid} Windows tray payload", result.Output);
}
}
[Theory]
[RequiresTools(["pwsh", "bash", "tar", "find", "od"])]
[UnsupportedOSPlatform("windows")]
[InlineData("linux-x64", "valid", 0)]
[InlineData("linux-arm64", "valid", 0)]
[InlineData("linux-x64", "wrong-rid", 1)]
[InlineData("linux-x64", "missing-icon", 1)]
[InlineData("linux-x64", "changed-icon", 1)]
[InlineData("linux-x64", "non-executable", 1)]
[InlineData("linux-x64", "extra-file", 1)]
[InlineData("linux-x64", "extra-directory", 1)]
[InlineData("linux-x64", "symlink-icon", 1)]
[InlineData("linux-x64", "symlink-executable", 1)]
public async Task LinuxArchiveVerifierChecksActualPayload(string rid, string scenario, int expectedExitCode)
{
Assert.SkipWhen(OperatingSystem.IsWindows(), "Linux bundles preserve Unix modes.");
using var workspace = TemporaryWorkspace.Create(output);
var source = Path.Combine(workspace.Path, "publish with spaces");
LinuxTrayTestPayload.Create(source, rid);
var layout = Path.Combine(workspace.Path, rid);
using var builder = new LayoutBuilder(layout, workspace.Path, rid, "Debug", "test", false,
trayDirectory: source, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
builder.CopyTray();
var tray = Path.Combine(layout, "tray");
switch (scenario)
{
case "wrong-rid":
LinuxTrayTestPayload.Create(tray, "linux-arm64");
break;
case "missing-icon":
File.Delete(Path.Combine(tray, "Aspire.png"));
break;
case "changed-icon":
File.WriteAllText(Path.Combine(tray, "Aspire.png"), "wrong icon");
break;
case "non-executable":
File.SetUnixFileMode(Path.Combine(tray, "aspire-tray"), UnixFileMode.UserRead | UnixFileMode.UserWrite);
break;
case "extra-file":
File.WriteAllText(Path.Combine(tray, "smoke.log"), "unexpected runtime content");
break;
case "extra-directory":
Directory.CreateDirectory(Path.Combine(tray, "empty"));
break;
case "symlink-icon":
case "symlink-executable":
var name = scenario == "symlink-icon" ? "Aspire.png" : "aspire-tray";
File.Delete(Path.Combine(tray, name));
File.CreateSymbolicLink(Path.Combine(tray, name), Path.Combine(source, name));
break;
}
var archive = await builder.CreateArchiveAsync();
var script = Path.Combine(workspace.Path, "verify.ps1");
File.WriteAllText(script, """
param([string]$Verifier, [string]$Archive, [string]$Rid)
& bash $Verifier $Archive $Rid
exit $LASTEXITCODE
""");
using var command = new PowerShellCommand(script, output)
.WithTimeout(TimeSpan.FromMinutes(1));
var result = await command.ExecuteAsync(
"-Verifier", $"\"{Path.Combine(RepoRoot.Path, "tools/CreateLayout/verify-linux-tray-payload.sh")}\"",
"-Archive", $"\"{archive}\"", "-Rid", rid);
result.EnsureExitCode(expectedExitCode);
if (expectedExitCode == 0)
{
Assert.Contains($"Verified Linux tray payload for {rid}.", result.Output);
}
}
[Theory]
[RequiresTools(["pwsh", "tar"])]
[UnsupportedOSPlatform("windows")]
[InlineData("valid", 0, "Packaged tray launchability check passed")]
[InlineData("verbose", 0, "Packaged tray launchability check passed")]
[InlineData("missing-executable", 1, "Packaged tray executable was not found")]
[InlineData("non-executable", 1, "Permission denied")]
[InlineData("nonzero-exit", 1, "failed with exit code 7")]
[InlineData("timeout", 1, "timed out after 1 seconds")]
[InlineData("invalid-archive", 1, "Failed to extract the packaged tray")]
public async Task NativeTrayLaunchCheckReportsFailuresWithoutRepairingPayload(string scenario, int expectedExitCode, string expectedMessage)
{
Assert.SkipWhen(OperatingSystem.IsWindows(), "Test executable uses a Unix shell.");
using var workspace = TemporaryWorkspace.Create(output);
var layout = Path.Combine(workspace.Path, "linux-x64");
var tray = Path.Combine(layout, "tray");
Directory.CreateDirectory(tray);
var executable = Path.Combine(tray, "aspire-tray");
File.WriteAllText(executable, scenario switch
{
"nonzero-exit" => "#!/bin/sh\nexit 7\n",
"timeout" => "#!/bin/sh\nexec sleep 60\n",
"verbose" => """
#!/bin/sh
i=0
while [ "$i" -lt 10000 ]; do
printf 'tray stdout\n'
printf 'tray stderr\n' >&2
i=$((i + 1))
done
""" + "\n",
_ => "#!/bin/sh\n[ \"$#\" -eq 1 ] && [ \"$1\" = '--help' ]\n"
});
File.SetUnixFileMode(executable, scenario == "non-executable"
? UnixFileMode.UserRead | UnixFileMode.UserWrite
: UnixFileMode.UserRead | UnixFileMode.UserWrite | UnixFileMode.UserExecute);
if (scenario == "missing-executable")
{
File.Delete(executable);
}
using var builder = new LayoutBuilder(layout, workspace.Path, "linux-x64", "Debug", "test", false,
trayDirectory: null, dashboardPath: null, managedPath: null, terminalHostPath: null, appHostServerPath: null);
var archive = await builder.CreateArchiveAsync();
if (scenario == "invalid-archive")
{
File.WriteAllText(archive, "not a tar archive");
}
using var command = new PowerShellCommand(Path.Combine(RepoRoot.Path, "eng/scripts/test-native-tray.ps1"), output)
.WithTimeout(TimeSpan.FromMinutes(1));
var result = await command.ExecuteAsync("-ArchivePath", $"\"{archive}\"", "-Rid", "linux-x64",
"-TimeoutSeconds", scenario == "timeout" ? "1" : "30");
result.EnsureExitCode(expectedExitCode);
Assert.Contains(expectedMessage, result.Output);
}
}