Stabilize real Gemini auth test isolation

Author: KSemenenko

GeminiSharpSDK.Tests/Integration/GeminiExecIntegrationTests.cs

@@ -1,20 +1,25 @@
 using ManagedCode.GeminiSharpSDK.Client;
 using ManagedCode.GeminiSharpSDK.Execution;
 using ManagedCode.GeminiSharpSDK.Tests.Shared;
+using ManagedCode.GeminiSharpSDK.Tests.TestSupport;
 
 namespace ManagedCode.GeminiSharpSDK.Tests.Integration;
 
 [Property("RequiresGeminiAuth", "true")]
+[ParallelLimiter<GeminiAuthParallelLimit>]
 public class GeminiExecIntegrationTests
 {
     private const string FirstPrompt = "Reply with short plain text: first.";
     private const string SecondPrompt = "Reply with short plain text: second.";
     private const string InvalidModel = "__geminisharp_invalid_model__";
+    private const string SandboxPrefix = "GeminiExecIntegrationTests";
+    private static readonly TimeSpan SandboxCommandTimeout = TimeSpan.FromSeconds(30);
 
     [Test]
     public async Task RunAsync_UsesDefaultProcessRunner_EndToEnd()
     {
         var settings = RealGeminiTestSupport.GetRequiredSettings();
+        using var sandbox = await RealGeminiTestSandbox.CreateAsync(SandboxPrefix, SandboxCommandTimeout);
 
         var exec = new GeminiExec();
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
@@ -23,6 +28,7 @@ public async Task RunAsync_UsesDefaultProcessRunner_EndToEnd()
         {
             Input = FirstPrompt,
             Model = settings.Model,
+            WorkingDirectory = sandbox.WorkingDirectory,
             CancellationToken = cancellation.Token,
         }));
 
@@ -34,14 +40,12 @@ public async Task RunAsync_UsesDefaultProcessRunner_EndToEnd()
     public async Task RunAsync_SecondCallPassesResumeArgument_EndToEnd()
     {
         var settings = RealGeminiTestSupport.GetRequiredSettings();
+        using var sandbox = await RealGeminiTestSandbox.CreateAsync(SandboxPrefix, SandboxCommandTimeout);
 
         using var client = RealGeminiTestSupport.CreateClient();
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(3));
 
-        var thread = client.StartThread(new ThreadOptions
-        {
-            Model = settings.Model,
-        });
+        var thread = client.StartThread(sandbox.CreateThreadOptions(settings.Model, ephemeral: false));
 
         var firstResult = await thread.RunAsync(
             FirstPrompt,
@@ -63,6 +67,7 @@ public async Task RunAsync_SecondCallPassesResumeArgument_EndToEnd()
     public async Task RunAsync_PropagatesNonZeroExitCode_EndToEnd()
     {
         var settings = RealGeminiTestSupport.GetRequiredSettings();
+        using var sandbox = await RealGeminiTestSandbox.CreateAsync(SandboxPrefix, SandboxCommandTimeout);
 
         var exec = new GeminiExec();
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
@@ -71,6 +76,7 @@ public async Task RunAsync_PropagatesNonZeroExitCode_EndToEnd()
         {
             Input = FirstPrompt,
             Model = InvalidModel,
+            WorkingDirectory = sandbox.WorkingDirectory,
             CancellationToken = cancellation.Token,
         }));
 

GeminiSharpSDK.Tests/Integration/RealGeminiIntegrationTests.cs

@@ -4,19 +4,16 @@
 using ManagedCode.GeminiSharpSDK.Internal;
 using ManagedCode.GeminiSharpSDK.Models;
 using ManagedCode.GeminiSharpSDK.Tests.Shared;
+using ManagedCode.GeminiSharpSDK.Tests.TestSupport;
 
 namespace ManagedCode.GeminiSharpSDK.Tests.Integration;
 
 [Property("RequiresGeminiAuth", "true")]
+[ParallelLimiter<GeminiAuthParallelLimit>]
 public class RealGeminiIntegrationTests
 {
-    private const string SolutionFileName = "ManagedCode.GeminiSharpSDK.slnx";
-    private const string TestsDirectoryName = "tests";
-    private const string SandboxDirectoryName = ".sandbox";
-    private const string SandboxPrefix = "RealGeminiIntegrationTests-SessionVisibility-";
-    private const string GitExecutableName = "git";
-    private const string GitInitArgument = "init";
-    private const string QuietArgument = "-q";
+    private const string SandboxPrefix = "RealGeminiIntegrationTests";
+    private const string SessionVisibilitySandboxPrefix = "RealGeminiIntegrationTests-SessionVisibility";
     private const string ListSessionsFlag = "--list-sessions";
     private const string GeminiDirectoryName = ".gemini";
     private const string ProjectsFileName = "projects.json";
@@ -34,9 +31,10 @@ public class RealGeminiIntegrationTests
     public async Task RunAsync_WithRealGeminiCli_ReturnsStructuredOutput()
     {
         var settings = RealGeminiTestSupport.GetRequiredSettings();
+        using var sandbox = await RealGeminiTestSandbox.CreateAsync(SandboxPrefix, CliCommandTimeout);
 
         using var client = RealGeminiTestSupport.CreateClient();
-        var thread = StartRealIntegrationThread(client, settings.Model);
+        var thread = StartRealIntegrationThread(client, settings.Model, sandbox.WorkingDirectory);
 
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
         var schema = IntegrationOutputSchemas.StatusOnly();
@@ -55,9 +53,10 @@ public async Task RunAsync_WithRealGeminiCli_ReturnsStructuredOutput()
     public async Task RunStreamedAsync_WithRealGeminiCli_YieldsCurrentStreamJsonEvents()
     {
         var settings = RealGeminiTestSupport.GetRequiredSettings();
+        using var sandbox = await RealGeminiTestSandbox.CreateAsync(SandboxPrefix, CliCommandTimeout);
 
         using var client = RealGeminiTestSupport.CreateClient();
-        var thread = StartRealIntegrationThread(client, settings.Model);
+        var thread = StartRealIntegrationThread(client, settings.Model, sandbox.WorkingDirectory);
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
 
         var streamed = await thread.RunStreamedAsync(
@@ -85,9 +84,10 @@ public async Task RunStreamedAsync_WithRealGeminiCli_YieldsCurrentStreamJsonEven
     public async Task RunAsync_WithRealGeminiCli_SecondTurnKeepsThreadId()
     {
         var settings = RealGeminiTestSupport.GetRequiredSettings();
+        using var sandbox = await RealGeminiTestSandbox.CreateAsync(SandboxPrefix, CliCommandTimeout);
 
         using var client = RealGeminiTestSupport.CreateClient();
-        var thread = StartRealIntegrationThread(client, settings.Model);
+        var thread = StartRealIntegrationThread(client, settings.Model, sandbox.WorkingDirectory);
         using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(3));
 
         var schema = IntegrationOutputSchemas.StatusOnly();
@@ -117,99 +117,47 @@ public async Task RunAsync_WithRealGeminiCli_SecondTurnKeepsThreadId()
     public async Task RunAsync_WithFreshWorkingDirectory_PersistsSessionVisibleToGeminiCli()
     {
         var settings = RealGeminiTestSupport.GetRequiredSettings();
-        var sandboxDirectory = await CreateGitSandboxDirectoryAsync();
+        using var sandbox = await RealGeminiTestSandbox.CreateAsync(
+            SessionVisibilitySandboxPrefix,
+            CliCommandTimeout);
+        var sandboxDirectory = sandbox.WorkingDirectory;
 
-        try
-        {
-            using var client = RealGeminiTestSupport.CreateClient();
-            var thread = client.StartThread(new ThreadOptions
-            {
-                Model = settings.Model,
-                WorkingDirectory = sandboxDirectory,
-                Ephemeral = false,
-            });
-            using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
-
-            var result = await thread.RunAsync(
-                ProjectSessionVisiblePrompt,
-                new TurnOptions { CancellationToken = cancellation.Token });
-
-            await Assert.That(result.Usage).IsNotNull();
-            await Assert.That(thread.Id).IsNotNull();
-
-            var persistedSessionPath = await FindPersistedSessionPathAsync(
-                sandboxDirectory,
-                thread.Id!,
-                SessionVisibilityTimeout);
-
-            await Assert.That(persistedSessionPath).IsNotNull();
-
-            var listSessionsResult = await RunGeminiAsync(
-                sandboxDirectory,
-                CliCommandTimeout,
-                ListSessionsFlag);
-
-            await Assert.That(listSessionsResult.ExitCode).IsEqualTo(0);
-            await Assert.That(string.Concat(listSessionsResult.StandardOutput, listSessionsResult.StandardError))
-                .Contains(thread.Id!);
-        }
-        finally
-        {
-            if (Directory.Exists(sandboxDirectory))
-            {
-                Directory.Delete(sandboxDirectory, recursive: true);
-            }
-        }
-    }
+        using var client = RealGeminiTestSupport.CreateClient();
+        var thread = client.StartThread(sandbox.CreateThreadOptions(settings.Model, ephemeral: false));
+        using var cancellation = new CancellationTokenSource(TimeSpan.FromMinutes(2));
 
-    private static GeminiThread StartRealIntegrationThread(GeminiClient client, string model)
-    {
-        return client.StartThread(new ThreadOptions
-        {
-            Model = model,
-        });
-    }
+        var result = await thread.RunAsync(
+            ProjectSessionVisiblePrompt,
+            new TurnOptions { CancellationToken = cancellation.Token });
 
-    private static async Task<string> CreateGitSandboxDirectoryAsync()
-    {
-        var repositoryRoot = ResolveRepositoryRootPath();
-        var sandboxDirectory = Path.Combine(
-            repositoryRoot,
-            TestsDirectoryName,
-            SandboxDirectoryName,
-            $"{SandboxPrefix}{Guid.NewGuid():N}");
-
-        Directory.CreateDirectory(sandboxDirectory);
-        var gitInitResult = await RunCommand(
-            GitExecutableName,
+        await Assert.That(result.Usage).IsNotNull();
+        await Assert.That(thread.Id).IsNotNull();
+
+        var persistedSessionPath = await FindPersistedSessionPathAsync(
             sandboxDirectory,
-            CliCommandTimeout,
-            GitInitArgument,
-            QuietArgument);
+            thread.Id!,
+            SessionVisibilityTimeout);
 
-        if (gitInitResult.ExitCode != 0)
-        {
-            throw new InvalidOperationException(
-                $"Failed to initialize git sandbox: {gitInitResult.StandardError}");
-        }
+        await Assert.That(persistedSessionPath).IsNotNull();
+
+        var listSessionsResult = await RunGeminiAsync(
+            sandboxDirectory,
+            CliCommandTimeout,
+            ListSessionsFlag);
 
-        return sandboxDirectory;
+        await Assert.That(listSessionsResult.ExitCode).IsEqualTo(0);
+        await Assert.That(string.Concat(listSessionsResult.StandardOutput, listSessionsResult.StandardError))
+            .Contains(thread.Id!);
     }
 
-    private static string ResolveRepositoryRootPath()
+    private static GeminiThread StartRealIntegrationThread(GeminiClient client, string model, string workingDirectory)
     {
-        var current = new DirectoryInfo(AppContext.BaseDirectory);
-        while (current is not null)
+        return client.StartThread(new ThreadOptions
         {
-            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.");
+            Model = model,
+            WorkingDirectory = workingDirectory,
+            Ephemeral = false,
+        });
     }
 
     private static async Task<string?> FindPersistedSessionPathAsync(

GeminiSharpSDK.Tests/TestSupport/GeminiAuthParallelLimit.cs

@@ -0,0 +1,8 @@
+using TUnit.Core.Interfaces;
+
+namespace ManagedCode.GeminiSharpSDK.Tests.TestSupport;
+
+internal sealed class GeminiAuthParallelLimit : IParallelLimit
+{
+    public int Limit => 1;
+}