Skip attach E2E test on in-box Windows PowerShell (20260614 image regression); cap CI job

.github/workflows/ci-test.yml

@@ -14,6 +14,10 @@ jobs:
       matrix:
         os: [ windows-latest, macos-latest, ubuntu-latest ]
     runs-on: ${{ matrix.os }}
+    # A normal run finishes in well under an hour (Windows, the slowest, is
+    # ~12-14 minutes); this caps a hung test instead of letting it ride
+    # GitHub's 6-hour default.
+    timeout-minutes: 60
     env:
       DOTNET_NOLOGO: true
       DOTNET_GENERATE_ASPNET_CERTIFICATE: false

test/PowerShellEditorServices.Test.E2E/DebugAdapterProtocolMessageTests.cs

@@ -24,6 +24,14 @@
 
 namespace PowerShellEditorServices.Test.E2E
 {
+    /// <remarks>
+    /// Every test in this class is skipped at discovery time on in-box Windows
+    /// PowerShell (via <see cref="SkippableFactOnWindowsPowerShellAttribute"/> and
+    /// <see cref="SkippableTheoryOnWindowsPowerShellAttribute"/>) because the shared
+    /// <see cref="InitializeAsync"/> debug-adapter startup can wedge there since the
+    /// 20260614 runner image, riding the job timeout. See
+    /// https://github.com/PowerShell/PowerShellEditorServices/issues/2323.
+    /// </remarks>
     [Trait("Category", "DAP")]
     // ITestOutputHelper is injected by XUnit
     // https://xunit.net/docs/capturing-output
@@ -238,16 +246,25 @@ private async Task<string> ReadScriptLogLineAsync()
                 }
             }
 
-            // return valid lines only
-            string nextLine = string.Empty;
-            while (nextLine is null || nextLine.Length == 0)
+            // Tail the log until a non-empty line is available. The awaited
+            // delay between reads matters: at EOF ReadLineAsync completes
+            // synchronously with null, so without it this is a tight loop that
+            // never releases its thread-pool thread and needlessly pressures
+            // the pool on constrained CI runners. Yielding keeps the tail loop
+            // cheap while we wait for the script to write.
+            while (true)
             {
-                nextLine = await scriptLogReader.ReadLineAsync(); //Might return null if at EOF because we created it above but the script hasn't written to it yet
+                string nextLine = await scriptLogReader.ReadLineAsync();
+                if (!string.IsNullOrEmpty(nextLine))
+                {
+                    return nextLine;
+                }
+
+                await Task.Delay(100);
             }
-            return nextLine;
         }
 
-        [Fact]
+        [SkippableFactOnWindowsPowerShell]
         public void CanInitializeWithCorrectServerSettings()
         {
             Assert.True(client.ServerSettings.SupportsConditionalBreakpoints);
@@ -259,7 +276,7 @@ public void CanInitializeWithCorrectServerSettings()
             Assert.True(client.ServerSettings.SupportsDelayedStackTraceLoading);
         }
 
-        [Fact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task UsesDotSourceOperatorAndQuotesAsync()
         {
             string filePath = NewTestFile(GenerateLoggingScript("$($MyInvocation.Line)"));
@@ -271,7 +288,7 @@ public async Task UsesDotSourceOperatorAndQuotesAsync()
             Assert.StartsWith(". '", actual);
         }
 
-        [Fact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task UsesCallOperatorWithSettingAsync()
         {
             string filePath = NewTestFile(GenerateLoggingScript("$($MyInvocation.Line)"));
@@ -283,7 +300,7 @@ public async Task UsesCallOperatorWithSettingAsync()
             Assert.StartsWith("& '", actual);
         }
 
-        [Fact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task CanLaunchScriptWithNoBreakpointsAsync()
         {
             string filePath = NewTestFile(GenerateLoggingScript("works"));
@@ -297,7 +314,7 @@ public async Task CanLaunchScriptWithNoBreakpointsAsync()
             Assert.Equal("works", actual);
         }
 
-        [SkippableFact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task CanSetBreakpointsAsync()
         {
             Skip.If(PsesStdioLanguageServerProcessHost.RunningInConstrainedLanguageMode,
@@ -348,7 +365,7 @@ public async Task CanSetBreakpointsAsync()
             Assert.Equal("after breakpoint", afterBreakpointActual);
         }
 
-        [SkippableFact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task FailsIfStacktraceRequestedWhenNotPaused()
         {
             Skip.If(PsesStdioLanguageServerProcessHost.RunningInConstrainedLanguageMode,
@@ -379,7 +396,7 @@ await Assert.ThrowsAsync<JsonRpcException>(() => client.RequestStackTrace(
             ));
         }
 
-        [SkippableFact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task SendsInitialLabelBreakpointForPerformanceReasons()
         {
             Skip.If(PsesStdioLanguageServerProcessHost.RunningInConstrainedLanguageMode,
@@ -437,7 +454,7 @@ public async Task SendsInitialLabelBreakpointForPerformanceReasons()
         // PowerShell, we avoid all issues with our test project (and the xUnit executable) not
         // having System.Windows.Forms deployed, and can instead rely on the Windows Global Assembly
         // Cache (GAC) to find it.
-        [SkippableFact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task CanStepPastSystemWindowsForms()
         {
             Skip.IfNot(PsesStdioLanguageServerProcessHost.IsWindowsPowerShell,
@@ -480,7 +497,7 @@ public async Task CanStepPastSystemWindowsForms()
         // commented. Since in some cases (such as Windows PowerShell, or the script not having a
         // backing ScriptFile) we just wrap the script with braces, we had a bug where the last
         // brace would be after the comment. We had to ensure we wrapped with newlines instead.
-        [Fact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task CanLaunchScriptWithCommentedLastLineAsync()
         {
             string script = GenerateLoggingScript("$($MyInvocation.Line)", "$(1+1)") + "# a comment at the end";
@@ -504,7 +521,7 @@ public async Task CanLaunchScriptWithCommentedLastLineAsync()
             Assert.Equal("2", await ReadScriptLogLineAsync());
         }
 
-        [SkippableFact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task CanRunPesterTestFile()
         {
             Skip.If(true, "Pester test is broken.");
@@ -549,7 +566,7 @@ public async Task CanRunPesterTestFile()
         [InlineData("-ProcessId 1234 -RunspaceId 5678", null, null, 1234, 5678, null)]
         [InlineData("-ProcessId 1234 -RunspaceId 5678 -ComputerName comp", "comp", null, 1234, 5678, null)]
         [InlineData("-CustomPipeName testpipe -RunspaceName rs-name", null, "testpipe", 0, 0, "rs-name")]
-        [SkippableTheory]
+        [SkippableTheoryOnWindowsPowerShell]
         public async Task CanLaunchScriptWithNewChildAttachSession(
             string paramString,
             string? expectedComputerName,
@@ -587,7 +604,7 @@ public async Task CanLaunchScriptWithNewChildAttachSession(
             await terminatedTcs.Task;
         }
 
-        [SkippableFact]
+        [SkippableFactOnWindowsPowerShell]
         public async Task CanLaunchScriptWithNewChildAttachSessionAsJob()
         {
             Skip.If(PsesStdioLanguageServerProcessHost.RunningInConstrainedLanguageMode,
@@ -621,7 +638,9 @@ public async Task CanLaunchScriptWithNewChildAttachSessionAsJob()
             await terminatedTcs.Task;
         }
 
-        [SkippableFact(Timeout = 15000)]
+        // Timeout is a per-test backstop; the Windows PowerShell skip happens at
+        // discovery time via the attribute (see the class remarks).
+        [SkippableFactOnWindowsPowerShell(Timeout = 15000)]
         public async Task CanAttachScriptWithPathMappings()
         {
             Skip.If(PsesStdioLanguageServerProcessHost.RunningInConstrainedLanguageMode,
@@ -762,6 +781,10 @@ WinPS will always need this.
                     if (((Get-Date) - $start).TotalSeconds -gt 10) {
                         throw 'Timeout waiting for Debug-Runspace to be subscribed.'
                     }
+
+                    # Yield a slice so this poll doesn't peg a core while the
+                    # runner is also servicing the attach handshake.
+                    Start-Sleep -Milliseconds 100
                 }
 
                 $ps.Invoke()

test/PowerShellEditorServices.Test.E2E/Hosts/SkippableFactOnWindowsPowerShellAttribute.cs

@@ -0,0 +1,56 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Xunit;
+using Xunit.Sdk;
+
+namespace PowerShellEditorServices.Test.E2E;
+
+/// <summary>
+/// The shared skip reason used by the discovery-time Windows PowerShell skip
+/// attributes for the end-to-end tests.
+/// </summary>
+/// <remarks>
+/// This is a runner-image regression, not a PSES code change: re-running a
+/// commit that predates all recent PRs (and previously passed) reproduces the
+/// same hang on the current windows-latest image, while macOS and Linux stay
+/// green. The wedge is in the in-box Windows PowerShell server's startup, so it
+/// affects both the debug adapter and language server end-to-end suites.
+/// </remarks>
+internal static class WindowsPowerShellServerStartupSkip
+{
+    public const string Reason = "The in-box Windows PowerShell server can wedge during startup on the current windows-latest runner image (a runner-image regression, not our code); see https://github.com/PowerShell/PowerShellEditorServices/issues/2323.";
+}
+
+/// <summary>
+/// A <see cref="SkippableFactAttribute"/> that additionally skips the test at
+/// <em>discovery</em> time when running under in-box Windows PowerShell.
+/// </summary>
+/// <remarks>
+/// A runtime <see cref="Skip.If(bool, string)"/> in the test body cannot prevent
+/// the per-test <c>IAsyncLifetime.InitializeAsync</c> from running first, because
+/// xUnit invokes the lifetime setup (which starts the PSES server) before the
+/// method body. When the hang occurs during that setup, a body-level skip is never
+/// reached. Setting <see cref="FactAttribute.Skip"/> here makes xUnit treat the
+/// test as statically skipped, so it never instantiates the test class or runs
+/// <c>InitializeAsync</c>. The <see cref="SkippableFactAttribute"/> discoverer is
+/// retained so runtime <see cref="Skip"/> calls (e.g. for Constrained Language
+/// Mode) still work when the test is not skipped at discovery time.
+/// <para>
+/// Caveat: xUnit still creates an <see cref="IClassFixture{TFixture}"/> even when
+/// every test method in the class is skipped at discovery time, so a fixture that
+/// starts the server in its own <c>InitializeAsync</c> (e.g. <c>LSPTestsFixture</c>)
+/// must additionally guard against starting it under Windows PowerShell.
+/// </para>
+/// </remarks>
+[XunitTestCaseDiscoverer("Xunit.Sdk.SkippableFactDiscoverer", "Xunit.SkippableFact")]
+public sealed class SkippableFactOnWindowsPowerShellAttribute : SkippableFactAttribute
+{
+    public SkippableFactOnWindowsPowerShellAttribute()
+    {
+        if (PsesStdioLanguageServerProcessHost.IsWindowsPowerShell)
+        {
+            Skip = WindowsPowerShellServerStartupSkip.Reason;
+        }
+    }
+}

test/PowerShellEditorServices.Test.E2E/Hosts/SkippableTheoryOnWindowsPowerShellAttribute.cs

@@ -0,0 +1,25 @@
+// Copyright (c) Microsoft Corporation.
+// Licensed under the MIT License.
+
+using Xunit;
+using Xunit.Sdk;
+
+namespace PowerShellEditorServices.Test.E2E;
+
+/// <summary>
+/// A <see cref="SkippableTheoryAttribute"/> that additionally skips the theory at
+/// <em>discovery</em> time when running under in-box Windows PowerShell. See
+/// <see cref="SkippableFactOnWindowsPowerShellAttribute"/> for why the skip must
+/// happen at discovery time rather than via an in-body <see cref="Skip"/> call.
+/// </summary>
+[XunitTestCaseDiscoverer("Xunit.Sdk.SkippableTheoryDiscoverer", "Xunit.SkippableFact")]
+public sealed class SkippableTheoryOnWindowsPowerShellAttribute : SkippableTheoryAttribute
+{
+    public SkippableTheoryOnWindowsPowerShellAttribute()
+    {
+        if (PsesStdioLanguageServerProcessHost.IsWindowsPowerShell)
+        {
+            Skip = WindowsPowerShellServerStartupSkip.Reason;
+        }
+    }
+}

test/PowerShellEditorServices.Test.E2E/LSPTestsFixtures.cs

@@ -42,6 +42,18 @@ public class LSPTestsFixture : IAsyncLifetime
 
         public async Task InitializeAsync()
         {
+            // All LSP end-to-end tests are skipped at discovery time on Windows
+            // PowerShell (see SkippableFactOnWindowsPowerShell), but xUnit still
+            // creates this class fixture even when every test method is skipped.
+            // The in-box Windows PowerShell server can wedge during startup on the
+            // current windows-latest runner image (a runner-image regression, not
+            // our code); see https://github.com/PowerShell/PowerShellEditorServices/issues/2323.
+            // So we must not start the server here on Windows PowerShell.
+            if (PsesStdioLanguageServerProcessHost.IsWindowsPowerShell)
+            {
+                return;
+            }
+
             (StreamReader stdout, StreamWriter stdin) = await _psesHost.Start();
 
             // Splice the streams together and enable debug logging of all messages sent and received
@@ -100,9 +112,16 @@ public async Task InitializeAsync()
 
         public async Task DisposeAsync()
         {
+            // The server is never started on Windows PowerShell (see
+            // InitializeAsync), so there is nothing to shut down there.
+            if (PsesLanguageClient is null)
+            {
+                return;
+            }
+
             await PsesLanguageClient.Shutdown();
             await _psesHost.Stop();
-            PsesLanguageClient?.Dispose();
+            PsesLanguageClient.Dispose();
         }
     }
 }