Add cross-platform unauthenticated Codex CLI smoke check

KSemenenko · KSemenenko · commit cc6fd76328a4 · 2026-03-05T17:13:01.000+01:00
diff --git a/AGENTS.md b/AGENTS.md
@@ -123,6 +123,7 @@ If no new rule is detected -> do not update the file.
 - For CLI process interaction tests, use the real installed `codex` CLI (no `FakeCodexProcessRunner` test doubles).
 - Treat `codex` CLI as a test prerequisite: ensure local/CI test setup installs `codex` before running CLI interaction tests; do not replace this with fakes.
 - CI must validate SDK on all Codex-supported desktop/server platforms (macOS, Linux, Windows): run build + tests and include a non-auth smoke check that `codex` is discoverable and invokable.
+- Cross-platform non-auth smoke must run `codex` from local installation in CI and verify unauthenticated behavior explicitly (for example `codex login status` in isolated profile returns "Not logged in"), proving binary discovery + process launch on each platform.
 - Real Codex integration tests must rely on existing local Codex CLI login/session only; do not read or require `OPENAI_API_KEY` in test setup.
 - Do not use nullable `TryGetSettings()` + early `return` skip patterns in real integration tests; resolve required settings directly and fail fast with actionable errors when missing.
 - Do not bypass integration tests on Windows with unconditional early returns; keep tests cross-platform for supported Codex CLI environments.
diff --git a/CodexSharpSDK.Tests/Integration/CodexCliSmokeTests.cs b/CodexSharpSDK.Tests/Integration/CodexCliSmokeTests.cs
@@ -5,12 +5,32 @@ namespace ManagedCode.CodexSharpSDK.Tests.Integration;
 
 public class CodexCliSmokeTests
 {
+    private const string SolutionFileName = "ManagedCode.CodexSharpSDK.slnx";
+    private const string TestsDirectoryName = "tests";
+    private const string SandboxDirectoryName = ".sandbox";
+    private const string SandboxPrefix = "CodexCliSmokeTests-";
     private const string PathEnvironmentVariable = "PATH";
+    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 AppDataDirectoryName = "AppData";
+    private const string RoamingDirectoryName = "Roaming";
+    private const string LocalDirectoryName = "Local";
+    private const string ConfigDirectoryName = ".config";
     private const string VersionFlag = "--version";
     private const string ExecCommand = "exec";
+    private const string LoginCommand = "login";
+    private const string StatusCommand = "status";
     private const string HelpFlag = "--help";
     private const string VersionToken = "codex-cli";
     private const string ExecHelpToken = "Run Codex non-interactively";
+    private const string NotLoggedInToken = "Not logged in";
 
     [Test]
     public async Task CodexCli_Smoke_FindExecutablePath_ResolvesExistingBinary()
@@ -24,7 +44,7 @@ public async Task CodexCli_Smoke_VersionCommand_ReturnsCodexCliVersion()
     {
         var executablePath = ResolveExecutablePath();
 
-        var result = await RunCodexAsync(executablePath, VersionFlag);
+        var result = await RunCodexAsync(executablePath, null, VersionFlag);
         await Assert.That(result.ExitCode).IsEqualTo(0);
 
         var output = string.Concat(result.StandardOutput, result.StandardError);
@@ -36,13 +56,34 @@ public async Task CodexCli_Smoke_ExecHelpCommand_ReturnsSuccess()
     {
         var executablePath = ResolveExecutablePath();
 
-        var result = await RunCodexAsync(executablePath, ExecCommand, HelpFlag);
+        var result = await RunCodexAsync(executablePath, null, ExecCommand, HelpFlag);
         await Assert.That(result.ExitCode).IsEqualTo(0);
 
         var output = string.Concat(result.StandardOutput, result.StandardError);
         await Assert.That(output.Contains(ExecHelpToken, StringComparison.Ordinal)).IsTrue();
     }
 
+    [Test]
+    public async Task CodexCli_Smoke_LoginStatusWithoutAuth_ReportsNotLoggedIn()
+    {
+        var executablePath = ResolveExecutablePath();
+        var sandboxDirectory = CreateSandboxDirectory();
+
+        try
+        {
+            var environmentOverrides = CreateUnauthenticatedEnvironmentOverrides(sandboxDirectory);
+            var result = await RunCodexAsync(executablePath, environmentOverrides, LoginCommand, StatusCommand);
+            await Assert.That(result.ExitCode).IsNotEqualTo(0);
+
+            var output = string.Concat(result.StandardOutput, result.StandardError);
+            await Assert.That(output.Contains(NotLoggedInToken, StringComparison.OrdinalIgnoreCase)).IsTrue();
+        }
+        finally
+        {
+            Directory.Delete(sandboxDirectory, recursive: true);
+        }
+    }
+
     private static string ResolveExecutablePath()
     {
         var resolvedPath = CodexCliLocator.FindCodexPath(null);
@@ -67,10 +108,63 @@ private static string ResolveExecutablePath()
         throw new InvalidOperationException("Failed to resolve Codex CLI path.");
     }
 
+    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 Dictionary<string, string> CreateUnauthenticatedEnvironmentOverrides(string sandboxDirectory)
+    {
+        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);
+
+        return new Dictionary<string, string>(StringComparer.Ordinal)
+        {
+            [HomeEnvironmentVariable] = sandboxDirectory,
+            [UserProfileEnvironmentVariable] = sandboxDirectory,
+            [XdgConfigHomeEnvironmentVariable] = configHome,
+            [AppDataEnvironmentVariable] = appData,
+            [LocalAppDataEnvironmentVariable] = localAppData,
+            [OpenAiApiKeyEnvironmentVariable] = string.Empty,
+            [OpenAiBaseUrlEnvironmentVariable] = string.Empty,
+            [CodexApiKeyEnvironmentVariable] = string.Empty,
+        };
+    }
+
     private static async Task<CodexProcessResult> RunCodexAsync(
         string executablePath,
-        string firstArgument,
-        string? secondArgument = null)
+        IReadOnlyDictionary<string, string>? environmentOverrides,
+        params string[] arguments)
     {
         var startInfo = new ProcessStartInfo(executablePath)
         {
@@ -80,10 +174,22 @@ private static async Task<CodexProcessResult> RunCodexAsync(
             CreateNoWindow = true,
         };
 
-        startInfo.ArgumentList.Add(firstArgument);
-        if (!string.IsNullOrWhiteSpace(secondArgument))
+        foreach (var argument in arguments)
         {
-            startInfo.ArgumentList.Add(secondArgument);
+            if (string.IsNullOrWhiteSpace(argument))
+            {
+                continue;
+            }
+
+            startInfo.ArgumentList.Add(argument);
+        }
+
+        if (environmentOverrides is not null)
+        {
+            foreach (var (key, value) in environmentOverrides)
+            {
+                startInfo.Environment[key] = value;
+            }
         }
 
         using var process = new Process { StartInfo = startInfo };
diff --git a/docs/Testing/strategy.md b/docs/Testing/strategy.md
@@ -15,6 +15,7 @@ Verify `ManagedCode.CodexSharpSDK` behavior against real Codex CLI contracts, wi
 - Use the real installed `codex` CLI for process interaction tests; do not use `FakeCodexProcessRunner` doubles.
 - Treat `codex` as a prerequisite for real integration runs and install it in CI/local setup before running those tests.
 - CI validates Codex CLI smoke behavior on Linux/macOS/Windows without requiring login: CLI must be discoverable and invokable.
+- Cross-platform CI smoke also validates unauthenticated behavior in an isolated profile (`codex login status` must report `Not logged in`), proving binary discovery + process launch without relying on local credentials.
 - Real integration runs must use existing Codex CLI login/session; test harness does not use API key environment variables.
 - Real integration model selection must be explicit: set `CODEX_TEST_MODEL` or define `model` in `~/.codex/config.toml` (no hardcoded fallback model).
 - Cover error paths and cancellation paths.
