Isolate real Codex tests from local MCP config

Author: KSemenenko

CodexSharpSDK.Tests/Integration/CodexExecIntegrationTests.cs

@@ -14,9 +14,9 @@ public class CodexExecIntegrationTests
     [Test]
     public async Task RunAsync_UsesDefaultProcessRunner_EndToEnd()
     {
-        var settings = RealCodexTestSupport.GetRequiredSettings();
+        using var settings = RealCodexTestSupport.GetRequiredSettings();
 
-        var exec = new CodexExec();
+        var exec = RealCodexTestSupport.CreateExec(settings);
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
 
         var lines = await DrainToListAsync(exec.RunAsync(new CodexExecArgs
@@ -37,9 +37,9 @@ public async Task RunAsync_UsesDefaultProcessRunner_EndToEnd()
     [Test]
     public async Task RunAsync_SecondCallPassesResumeArgument_EndToEnd()
     {
-        var settings = RealCodexTestSupport.GetRequiredSettings();
+        using var settings = RealCodexTestSupport.GetRequiredSettings();
 
-        using var client = RealCodexTestSupport.CreateClient();
+        using var client = RealCodexTestSupport.CreateClient(settings);
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(3));
 
         var thread = client.StartThread(new ThreadOptions
@@ -70,9 +70,9 @@ public async Task RunAsync_SecondCallPassesResumeArgument_EndToEnd()
     [Test]
     public async Task RunAsync_PropagatesNonZeroExitCode_EndToEnd()
     {
-        var settings = RealCodexTestSupport.GetRequiredSettings();
+        using var settings = RealCodexTestSupport.GetRequiredSettings();
 
-        var exec = new CodexExec();
+        var exec = RealCodexTestSupport.CreateExec(settings);
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
 
         var action = async () => await DrainAsync(exec.RunAsync(new CodexExecArgs

CodexSharpSDK.Tests/Integration/RealCodexIntegrationTests.cs

@@ -12,9 +12,9 @@ public class RealCodexIntegrationTests
     [Test]
     public async Task RunAsync_WithRealCodexCli_ReturnsStructuredOutput()
     {
-        var settings = RealCodexTestSupport.GetRequiredSettings();
+        using var settings = RealCodexTestSupport.GetRequiredSettings();
 
-        using var client = RealCodexTestSupport.CreateClient();
+        using var client = RealCodexTestSupport.CreateClient(settings);
         var thread = StartRealIntegrationThread(client, settings.Model);
 
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
@@ -33,9 +33,9 @@ public async Task RunAsync_WithRealCodexCli_ReturnsStructuredOutput()
     [Test]
     public async Task RunStreamedAsync_WithRealCodexCli_YieldsCompletedTurnEvent()
     {
-        var settings = RealCodexTestSupport.GetRequiredSettings();
+        using var settings = RealCodexTestSupport.GetRequiredSettings();
 
-        using var client = RealCodexTestSupport.CreateClient();
+        using var client = RealCodexTestSupport.CreateClient(settings);
         var thread = StartRealIntegrationThread(client, settings.Model);
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
 
@@ -63,9 +63,9 @@ public async Task RunStreamedAsync_WithRealCodexCli_YieldsCompletedTurnEvent()
     [Test]
     public async Task RunAsync_WithRealCodexCli_SecondTurnKeepsThreadId()
     {
-        var settings = RealCodexTestSupport.GetRequiredSettings();
+        using var settings = RealCodexTestSupport.GetRequiredSettings();
 
-        using var client = RealCodexTestSupport.CreateClient();
+        using var client = RealCodexTestSupport.CreateClient(settings);
         var thread = StartRealIntegrationThread(client, settings.Model);
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(3));
 
@@ -95,9 +95,9 @@ public async Task RunAsync_WithRealCodexCli_SecondTurnKeepsThreadId()
     [Test]
     public async Task RunAsync_WithExplicitNonEphemeralOverride_PersistsRolloutWhenClientConfigEnablesEphemeral()
     {
-        var settings = RealCodexTestSupport.GetRequiredSettings();
+        using var settings = RealCodexTestSupport.GetRequiredSettings();
 
-        using var client = RealCodexTestSupport.CreateClient(new CodexOptions
+        using var client = RealCodexTestSupport.CreateClient(settings, new CodexOptions
         {
             Config = new JsonObject
             {
@@ -123,6 +123,7 @@ public async Task RunAsync_WithExplicitNonEphemeralOverride_PersistsRolloutWhenC
         await Assert.That(thread.Id).IsNotNull();
 
         var rolloutPath = await RealCodexTestSupport.FindPersistedRolloutPathAsync(
+            settings,
             thread.Id!,
             TimeSpan.FromSeconds(10));
 

CodexSharpSDK.Tests/Shared/RealCodexTestSupport.cs

@@ -1,13 +1,39 @@
+using System.Collections;
 using System.Diagnostics;
 using ManagedCode.CodexSharpSDK.Client;
 using ManagedCode.CodexSharpSDK.Configuration;
+using ManagedCode.CodexSharpSDK.Execution;
 using ManagedCode.CodexSharpSDK.Internal;
+using Microsoft.Extensions.Logging;
 
 namespace ManagedCode.CodexSharpSDK.Tests.Shared;
 
 internal static class RealCodexTestSupport
 {
     private const string ModelEnvVar = "CODEX_TEST_MODEL";
+    private const string SolutionFileName = "ManagedCode.CodexSharpSDK.slnx";
+    private const string TestsDirectoryName = "tests";
+    private const string SandboxDirectoryName = ".sandbox";
+    private const string SandboxPrefix = "RealCodexTestSupport-";
+    private const string CodexHomeEnvironmentVariable = "CODEX_HOME";
+    private const string HomeEnvironmentVariable = "HOME";
+    private const string UserProfileEnvironmentVariable = "USERPROFILE";
+    private const string XdgConfigHomeEnvironmentVariable = "XDG_CONFIG_HOME";
+    private const string AppDataEnvironmentVariable = "APPDATA";
+    private const string LocalAppDataEnvironmentVariable = "LOCALAPPDATA";
+    private const string OpenAiApiKeyEnvironmentVariable = "OPENAI_API_KEY";
+    private const string OpenAiBaseUrlEnvironmentVariable = "OPENAI_BASE_URL";
+    private const string CodexApiKeyEnvironmentVariable = "CODEX_API_KEY";
+    private const string CodexHomeDirectoryName = ".codex";
+    private const string ConfigDirectoryName = ".config";
+    private const string AppDataDirectoryName = "AppData";
+    private const string RoamingDirectoryName = "Roaming";
+    private const string LocalDirectoryName = "Local";
+    private const string ConfigFileName = "config.toml";
+    private const string SessionsDirectoryName = "sessions";
+    private const string AuthFileName = "auth.json";
+    private const string KosAuthFileName = "kos-auth.json";
+    private const string SandboxCleanupFailureDataKey = "SandboxCleanupFailure";
 
     public static RealCodexTestSettings GetRequiredSettings()
     {
@@ -17,20 +43,46 @@ public static RealCodexTestSettings GetRequiredSettings()
                 "Real Codex tests require the codex CLI. Install it first and ensure it is available in PATH.");
         }
 
-        return new RealCodexTestSettings(ResolveModel());
+        var sandboxDirectory = CreateSandboxDirectory();
+        try
+        {
+            var model = ResolveModel();
+            var environmentOverrides = CreateAuthenticatedEnvironmentOverrides(sandboxDirectory, model);
+            return new RealCodexTestSettings(
+                model,
+                sandboxDirectory,
+                environmentOverrides[CodexHomeEnvironmentVariable],
+                environmentOverrides);
+        }
+        catch (Exception exception)
+        {
+            AttachCleanupFailure(exception, sandboxDirectory);
+            throw;
+        }
     }
 
-    public static CodexClient CreateClient(CodexOptions? options = null)
+    public static CodexClient CreateClient(RealCodexTestSettings settings, CodexOptions? options = null)
     {
-        return new CodexClient(options ?? new CodexOptions());
+        ArgumentNullException.ThrowIfNull(settings);
+        return new CodexClient(CreateCodexOptions(settings, options));
     }
 
-    public static async Task<string?> FindPersistedRolloutPathAsync(string threadId, TimeSpan timeout)
+    public static CodexExec CreateExec(RealCodexTestSettings settings, ILogger? logger = null)
     {
+        ArgumentNullException.ThrowIfNull(settings);
+        return new CodexExec(environmentOverride: settings.EnvironmentOverrides, logger: logger);
+    }
+
+    public static async Task<string?> FindPersistedRolloutPathAsync(
+        RealCodexTestSettings settings,
+        string threadId,
+        TimeSpan timeout)
+    {
+        ArgumentNullException.ThrowIfNull(settings);
         ArgumentException.ThrowIfNullOrWhiteSpace(threadId);
 
-        var sessionsPath = GetCodexSessionsPath();
-        if (sessionsPath is null || !Directory.Exists(sessionsPath))
+        var sessionsPath = Path.Combine(settings.CodexHomeDirectory, SessionsDirectoryName);
+        if (!Directory.Exists(sessionsPath))
         {
             return null;
         }
@@ -127,24 +179,24 @@ private static string ResolveModel()
 
     private static string? GetCodexConfigPath()
     {
-        var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
-        if (string.IsNullOrWhiteSpace(homeDirectory))
+        var codexHomeDirectory = GetSourceCodexHomePath();
+        if (string.IsNullOrWhiteSpace(codexHomeDirectory))
         {
             return null;
         }
 
-        return Path.Combine(homeDirectory, ".codex", "config.toml");
+        return Path.Combine(codexHomeDirectory, ConfigFileName);
     }
 
-    private static string? GetCodexSessionsPath()
+    private static string? GetSourceCodexHomePath()
     {
         var homeDirectory = Environment.GetFolderPath(Environment.SpecialFolder.UserProfile);
         if (string.IsNullOrWhiteSpace(homeDirectory))
         {
             return null;
         }
 
-        return Path.Combine(homeDirectory, ".codex", "sessions");
+        return Path.Combine(homeDirectory, CodexHomeDirectoryName);
     }
 
     private static bool IsCodexAvailable()
@@ -160,6 +212,177 @@ private static bool IsCodexAvailable()
             OperatingSystem.IsWindows(),
             out _);
     }
+
+    private static CodexOptions CreateCodexOptions(RealCodexTestSettings settings, CodexOptions? options)
+    {
+        var environmentOverrides = new Dictionary<string, string>(settings.EnvironmentOverrides, StringComparer.Ordinal);
+        if (options?.EnvironmentVariables is not null)
+        {
+            foreach (var (key, value) in options.EnvironmentVariables)
+            {
+                environmentOverrides[key] = value;
+            }
+        }
+
+        return new CodexOptions
+        {
+            CodexExecutablePath = options?.CodexExecutablePath,
+            BaseUrl = options?.BaseUrl,
+            ApiKey = options?.ApiKey,
+            Config = options?.Config,
+            EnvironmentVariables = environmentOverrides,
+            Logger = options?.Logger,
+        };
+    }
+
+    private static Dictionary<string, string> CreateAuthenticatedEnvironmentOverrides(string sandboxDirectory, string model)
+    {
+        var codexHome = Path.Combine(sandboxDirectory, CodexHomeDirectoryName);
+        var configHome = Path.Combine(sandboxDirectory, ConfigDirectoryName);
+        var appData = Path.Combine(sandboxDirectory, AppDataDirectoryName, RoamingDirectoryName);
+        var localAppData = Path.Combine(sandboxDirectory, AppDataDirectoryName, LocalDirectoryName);
+
+        Directory.CreateDirectory(codexHome);
+        Directory.CreateDirectory(configHome);
+        Directory.CreateDirectory(appData);
+        Directory.CreateDirectory(localAppData);
+
+        WriteIsolatedCodexConfig(codexHome, model);
+        CopyAuthenticationArtifacts(codexHome);
+
+        var environmentOverrides = Environment.GetEnvironmentVariables()
+            .Cast<DictionaryEntry>()
+            .Where(entry => entry.Key is string && entry.Value is not null)
+            .ToDictionary(
+                entry => entry.Key.ToString() ?? string.Empty,
+                entry => entry.Value?.ToString() ?? string.Empty,
+                StringComparer.Ordinal);
+
+        environmentOverrides[CodexHomeEnvironmentVariable] = codexHome;
+        environmentOverrides[HomeEnvironmentVariable] = sandboxDirectory;
+        environmentOverrides[UserProfileEnvironmentVariable] = sandboxDirectory;
+        environmentOverrides[XdgConfigHomeEnvironmentVariable] = configHome;
+        environmentOverrides[AppDataEnvironmentVariable] = appData;
+        environmentOverrides[LocalAppDataEnvironmentVariable] = localAppData;
+        environmentOverrides[OpenAiApiKeyEnvironmentVariable] = string.Empty;
+        environmentOverrides[OpenAiBaseUrlEnvironmentVariable] = string.Empty;
+        environmentOverrides[CodexApiKeyEnvironmentVariable] = string.Empty;
+
+        return environmentOverrides;
+    }
+
+    private static void WriteIsolatedCodexConfig(string codexHomeDirectory, string model)
+    {
+        var escapedModel = model
+            .Replace("\\", "\\\\", StringComparison.Ordinal)
+            .Replace("\"", "\\\"", StringComparison.Ordinal);
+        var configPath = Path.Combine(codexHomeDirectory, ConfigFileName);
+        File.WriteAllText(configPath, $"model = \"{escapedModel}\"{Environment.NewLine}");
+    }
+
+    private static void CopyAuthenticationArtifacts(string codexHomeDirectory)
+    {
+        var sourceCodexHome = GetSourceCodexHomePath();
+        if (string.IsNullOrWhiteSpace(sourceCodexHome) || !Directory.Exists(sourceCodexHome))
+        {
+            throw new InvalidOperationException(
+                "Real Codex tests require an existing local Codex login. Run 'codex login' first.");
+        }
+
+        var copiedFiles = 0;
+        copiedFiles += CopyAuthenticationArtifactIfExists(sourceCodexHome, codexHomeDirectory, AuthFileName);
+        copiedFiles += CopyAuthenticationArtifactIfExists(sourceCodexHome, codexHomeDirectory, KosAuthFileName);
+
+        if (copiedFiles == 0)
+        {
+            throw new InvalidOperationException(
+                "Real Codex tests require an existing local Codex login. Run 'codex login' first.");
+        }
+    }
+
+    private static int CopyAuthenticationArtifactIfExists(
+        string sourceCodexHome,
+        string destinationCodexHome,
+        string fileName)
+    {
+        var sourcePath = Path.Combine(sourceCodexHome, fileName);
+        if (!File.Exists(sourcePath))
+        {
+            return 0;
+        }
+
+        var destinationPath = Path.Combine(destinationCodexHome, fileName);
+        File.Copy(sourcePath, destinationPath, overwrite: true);
+        return 1;
+    }
+
+    private static string CreateSandboxDirectory()
+    {
+        var repositoryRoot = ResolveRepositoryRootPath();
+        var sandboxDirectory = Path.Combine(
+            repositoryRoot,
+            TestsDirectoryName,
+            SandboxDirectoryName,
+            $"{SandboxPrefix}{Guid.NewGuid():N}");
+        Directory.CreateDirectory(sandboxDirectory);
+        return sandboxDirectory;
+    }
+
+    private static string ResolveRepositoryRootPath()
+    {
+        var current = new DirectoryInfo(AppContext.BaseDirectory);
+        while (current is not null)
+        {
+            if (File.Exists(Path.Combine(current.FullName, SolutionFileName)))
+            {
+                return current.FullName;
+            }
+
+            current = current.Parent;
+        }
+
+        throw new InvalidOperationException("Could not locate repository root from test execution directory.");
+    }
+
+    private static void AttachCleanupFailure(Exception originalException, string sandboxDirectory)
+    {
+        try
+        {
+            if (Directory.Exists(sandboxDirectory))
+            {
+                Directory.Delete(sandboxDirectory, recursive: true);
+            }
+        }
+        catch (IOException cleanupException)
+        {
+            originalException.Data[SandboxCleanupFailureDataKey] = cleanupException;
+        }
+        catch (UnauthorizedAccessException cleanupException)
+        {
+            originalException.Data[SandboxCleanupFailureDataKey] = cleanupException;
+        }
+    }
 }
 
-internal sealed record RealCodexTestSettings(string Model);
+internal sealed class RealCodexTestSettings(
+    string model,
+    string sandboxDirectory,
+    string codexHomeDirectory,
+    IReadOnlyDictionary<string, string> environmentOverrides) : IDisposable
+{
+    public string Model { get; } = model;
+
+    public string SandboxDirectory { get; } = sandboxDirectory;
+
+    public string CodexHomeDirectory { get; } = codexHomeDirectory;
+
+    public IReadOnlyDictionary<string, string> EnvironmentOverrides { get; } = environmentOverrides;
+
+    public void Dispose()
+    {
+        if (Directory.Exists(SandboxDirectory))
+        {
+            Directory.Delete(SandboxDirectory, recursive: true);
+        }
+    }
+}