|
// Licensed to the .NET Foundation under one or more agreements.
// The .NET Foundation licenses this file to you under the MIT license.
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Net;
using System.Net.Sockets;
using System.Text;
namespace Microsoft.AspNetCore.Components.Testing.Infrastructure;
/// <summary>
/// Represents a running app instance started via
/// <see cref="ServerFixture{TTestAssembly}.StartServerAsync{TApp}"/>.
/// Each instance has a unique <see cref="Id"/> used for YARP proxy routing
/// via the <c>X-Test-Backend</c> header.
/// </summary>
/// <remarks>
/// Disposing a <see cref="ServerInstance"/> kills the app process and unregisters
/// it from the proxy. Instances are typically disposed by the <see cref="ServerFixture{TTestAssembly}"/>
/// when the collection is torn down, but tests can also dispose them early for
/// explicit lifecycle control.
/// </remarks>
public class ServerInstance : IAsyncDisposable
{
private Process? _process;
private readonly string _proxyUrl;
private readonly Action<string>? _onDisposed;
private readonly StringBuilder _stdoutBuffer = new();
private readonly StringBuilder _stderrBuffer = new();
/// <summary>
/// Unique identifier for this server instance (used for <c>X-Test-Backend</c> header).
/// </summary>
public string Id { get; } = Guid.NewGuid().ToString("N")[..8];
/// <summary>
/// The app name (matches the key in the E2E manifest).
/// </summary>
public string AppName { get; }
/// <summary>
/// Direct URL of the app process (random port, localhost).
/// </summary>
public string AppUrl { get; private set; } = "";
/// <summary>
/// Public-facing URL from the manifest (for OAuth redirect URIs, etc.).
/// </summary>
public string? PublicUrl { get; private set; }
/// <summary>
/// URL that tests should navigate to. Always routes through the proxy.
/// Tests must set <c>ExtraHTTPHeaders["X-Test-Backend"] = Id</c> to reach this instance.
/// </summary>
public string TestUrl => _proxyUrl;
internal string Key { get; }
internal ServerInstance(string appName, string key, string proxyUrl, Action<string>? onDisposed)
{
AppName = appName;
Key = key;
_proxyUrl = proxyUrl;
_onDisposed = onDisposed;
}
internal async Task LaunchAsync(
E2EAppEntry appEntry,
ServerStartOptions options,
string testAssemblyLocation,
string testAssemblyName,
string readyUrl,
Task readySignal)
{
var port = GetAvailablePort();
AppUrl = $"http://localhost:{port}";
PublicUrl = appEntry.PublicUrl;
var startInfo = BuildProcessStartInfo(appEntry);
// Build unified environment: infrastructure, then manifest, then options.
// Each layer can override the previous one. Environment variables already
// set in the current process (e.g., CI variables) take precedence over
// defaults but can themselves be overridden by explicit option values.
var environment = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
// Infrastructure variables (always set)
environment["ASPNETCORE_URLS"] = AppUrl;
environment["ASPNETCORE_HOSTINGSTARTUPASSEMBLIES"] = testAssemblyName;
environment["DOTNET_STARTUP_HOOKS"] = testAssemblyLocation;
environment["TEST_PARENT_PID"] = Environment.ProcessId.ToString(CultureInfo.InvariantCulture);
environment["ASPNETCORE_ENVIRONMENT"] = "Development";
environment["E2E_READY_URL"] = readyUrl;
// Propagate DOTNET_ROOT so published app hosts can find the correct runtime
// (e.g. when building against a preview SDK that isn't globally installed).
var dotnetRoot = Environment.GetEnvironmentVariable("DOTNET_ROOT");
if (!string.IsNullOrEmpty(dotnetRoot))
{
environment["DOTNET_ROOT"] = dotnetRoot;
}
// Service override: static method pattern (WAF-like)
if (options.ServiceOverrideTypeName is not null)
{
environment["E2E_TEST_SERVICES_TYPE"] = options.ServiceOverrideTypeName;
environment["E2E_TEST_SERVICES_METHOD"] = options.ServiceOverrideMethodName!;
}
// Manifest-defined environment variables
foreach (var (key, value) in appEntry.EnvironmentVariables)
{
environment[key] = value;
}
// User-specified environment variables override all previous values
foreach (var (key, value) in options.EnvironmentVariables)
{
environment[key] = value;
}
// Apply collected environment to the process
foreach (var (key, value) in environment)
{
startInfo.Environment[key] = value;
}
_process = Process.Start(startInfo)
?? throw new InvalidOperationException($"Failed to start process for '{AppName}'.");
_ = DrainStreamAsync(_process.StandardOutput, $"[{AppName}:{Id}] ", _stdoutBuffer);
_ = DrainStreamAsync(_process.StandardError, $"[{AppName}:{Id} ERR] ", _stderrBuffer);
// Wait for the app to signal readiness via the callback, with timeout as fallback.
// Also monitor for early process exit to fail fast with diagnostics.
var timeoutTask = Task.Delay(options.ReadinessTimeoutMs);
var processExitTask = _process.WaitForExitAsync();
var completed = await Task.WhenAny(readySignal, timeoutTask, processExitTask).ConfigureAwait(false);
if (completed == processExitTask)
{
// Give drain tasks a moment to capture remaining output
await Task.Delay(100).ConfigureAwait(false);
var output = GetCapturedOutput();
throw new InvalidOperationException(
$"App '{AppName}' process exited with code {_process.ExitCode} before signaling readiness. " +
$"Command: {appEntry.Executable} {appEntry.Arguments}.\n" +
$"--- Captured output ---\n{output}");
}
if (completed == timeoutTask)
{
var output = GetCapturedOutput();
throw new TimeoutException(
$"App '{AppName}' did not signal readiness within {options.ReadinessTimeoutMs}ms. " +
$"Process still running: {!_process.HasExited}. " +
$"Command: {appEntry.Executable} {appEntry.Arguments}.\n" +
$"--- Captured output ---\n{output}");
}
}
/// <inheritdoc/>
public async ValueTask DisposeAsync()
{
_onDisposed?.Invoke(Key);
if (_process is { HasExited: false })
{
_process.Kill(entireProcessTree: true);
await _process.WaitForExitAsync().ConfigureAwait(false);
}
_process?.Dispose();
}
internal static string ComputeKey(string appName, ServerStartOptions options)
{
var sb = new StringBuilder(appName);
if (options.ServiceOverrideTypeName is not null)
{
sb.Append('|').Append(options.ServiceOverrideTypeName);
sb.Append(':').Append(options.ServiceOverrideMethodName);
}
foreach (var kvp in options.EnvironmentVariables.OrderBy(x => x.Key))
{
sb.Append('|').Append(kvp.Key).Append('=').Append(kvp.Value);
}
return sb.ToString();
}
static ProcessStartInfo BuildProcessStartInfo(E2EAppEntry appEntry)
{
var executable = appEntry.Executable;
var args = appEntry.Arguments;
string? workingDir = null;
if (appEntry.WorkingDirectory is not null)
{
workingDir = Path.Combine(AppContext.BaseDirectory, appEntry.WorkingDirectory);
// Resolve relative executable path within the working directory
if (executable != "dotnet")
{
executable = Path.Combine(workingDir, executable);
}
}
var startInfo = new ProcessStartInfo(executable, args)
{
UseShellExecute = false,
RedirectStandardOutput = true,
RedirectStandardError = true,
CreateNoWindow = true,
};
if (workingDir is not null)
{
startInfo.WorkingDirectory = workingDir;
}
return startInfo;
}
static int GetAvailablePort()
{
var listener = new TcpListener(IPAddress.Loopback, 0);
listener.Start();
var port = ((IPEndPoint)listener.LocalEndpoint).Port;
listener.Stop();
return port;
}
static async Task DrainStreamAsync(StreamReader reader, string prefix, StringBuilder buffer)
{
try
{
while (await reader.ReadLineAsync().ConfigureAwait(false) is { } line)
{
lock (buffer)
{
buffer.AppendLine(line);
}
Console.WriteLine($"{prefix}{line}");
}
}
catch
{
// Process exited
}
}
string GetCapturedOutput()
{
var sb = new StringBuilder();
lock (_stdoutBuffer)
{
if (_stdoutBuffer.Length > 0)
{
sb.AppendLine("[STDOUT]");
sb.Append(_stdoutBuffer);
}
}
lock (_stderrBuffer)
{
if (_stderrBuffer.Length > 0)
{
sb.AppendLine("[STDERR]");
sb.Append(_stderrBuffer);
}
}
return sb.Length > 0 ? sb.ToString() : "(no output captured)";
}
}
|