Revert container startup command in container provider (#5556)

rishabhmalikMS · web-flow · commit 8a5f98c7c3fd · 2026-05-11T04:40:14.000Z
* container startup windows command fix

* updated knob name and L0 tests

* added debug logs
diff --git a/src/Agent.Sdk/Knob/AgentKnobs.cs b/src/Agent.Sdk/Knob/AgentKnobs.cs
@@ -964,12 +964,12 @@ public class AgentKnobs
             new EnvironmentKnobSource("AGENT_ENABLE_DOCKER_EXEC_DIAGNOSTICS"),
             new BuiltInDefaultKnobSource("false"));
 
-        public static readonly Knob UseNodeVersionStrategy = new Knob(
-            nameof(UseNodeVersionStrategy),
-            "If true, use the strategy pattern for Node.js version selection (both host and container). This provides centralized node selection logic with EOL policy enforcement. Set to false to use legacy node selection logic.",
-            new PipelineFeatureSource("UseNodeVersionStrategy"),
-            new RuntimeKnobSource("AGENT_USE_NODE_STRATEGY"),
-            new EnvironmentKnobSource("AGENT_USE_NODE_STRATEGY"),
+        public static readonly Knob UseEnhancedNodeSelection = new Knob(
+            nameof(UseEnhancedNodeSelection),
+            "If true, use the enhanced Node.js version selection logic (both host and container). This provides centralized node selection with EOL policy enforcement and correct container keepalive. Set to false to use legacy node selection logic.",
+            new PipelineFeatureSource("UseEnhancedNodeSelection"),
+            new RuntimeKnobSource("AGENT_USE_ENHANCED_NODE_SELECTION"),
+            new EnvironmentKnobSource("AGENT_USE_ENHANCED_NODE_SELECTION"),
             new BuiltInDefaultKnobSource("false"));
     }
 }
diff --git a/src/Agent.Worker/ContainerOperationProvider.cs b/src/Agent.Worker/ContainerOperationProvider.cs
@@ -553,7 +553,7 @@ private async Task StartContainerAsync(IExecutionContext executionContext, Conta
                 container.MountVolumes.Add(new MountVolume(taskKeyFile, container.TranslateToContainerPath(taskKeyFile)));
             }
 
-            bool UseNodeVersionStrategy = AgentKnobs.UseNodeVersionStrategy.GetValue(executionContext).AsBoolean();
+            bool useEnhancedNodeSelection = AgentKnobs.UseEnhancedNodeSelection.GetValue(executionContext).AsBoolean();
             bool useNode20ToStartContainer = AgentKnobs.UseNode20ToStartContainer.GetValue(executionContext).AsBoolean();
             bool useNode24ToStartContainer = AgentKnobs.UseNode24ToStartContainer.GetValue(executionContext).AsBoolean();
             bool useAgentNode = false;
@@ -581,17 +581,18 @@ string containerNodePath(string nodeFolder)
                                                                     dockerObject: container.ContainerImage,
                                                                     options: $"--format=\"{{{{index .Config.Labels \\\"{_nodeJsPathLabel}\\\"}}}}\"");
 
-                if (UseNodeVersionStrategy)
+                if (useEnhancedNodeSelection)
                 {
+                    executionContext.Debug("[ContainerSetup] Using enhanced node selection path for container startup.");
                     bool isWindowsContainer = container.ImageOS == PlatformUtil.OS.Windows;            
                     
                     container.ContainerCommand = isWindowsContainer
-                        ? "cmd.exe /c timeout /t -1 /nobreak > nul"
+                        ? "cmd.exe /c ping -t localhost > nul"
                         : "sleep infinity";
                 }
                 else
                 {
-                    
+                    executionContext.Debug("[ContainerSetup] Using legacy node selection path for container startup.");
                     // Legacy approach: Use node-based startup command
                     string nodeSetInterval(string node)
                     {
@@ -674,10 +675,11 @@ string useDoubleQuotes(string value)
 
                     executionContext.Warning($"Docker container {container.ContainerId} is not in running state.");
                 }
-                else if (UseNodeVersionStrategy && container.IsJobContainer)
+                else if (useEnhancedNodeSelection && container.IsJobContainer)
                 {
                     try
                     {
+                        executionContext.Debug("[ContainerSetup] Calling enhanced node selection path for container startup.");
                         SetContainerNodePathWithOrchestrator(executionContext, container);
                     }
                     catch (Exception ex)
diff --git a/src/Agent.Worker/ContainerOperationProviderEnhanced.cs b/src/Agent.Worker/ContainerOperationProviderEnhanced.cs
@@ -662,7 +662,7 @@ private async Task StartContainerAsync(IExecutionContext executionContext, Conta
                     $"{m.SourceVolumePath ?? "anonymous"}:{m.TargetVolumePath}{(m.ReadOnly ? ":ro" : "")}");
                 trace.Info($"Configured {container.MountVolumes.Count} volume mounts: {string.Join(", ", mountSummary)}");
 
-                bool useNodeVersionStrategy = AgentKnobs.UseNodeVersionStrategy.GetValue(executionContext).AsBoolean();
+                bool useEnhancedNodeSelection = AgentKnobs.UseEnhancedNodeSelection.GetValue(executionContext).AsBoolean();
                 bool useNode20ToStartContainer = AgentKnobs.UseNode20ToStartContainer.GetValue(executionContext).AsBoolean();
                 bool useNode24ToStartContainer = AgentKnobs.UseNode24ToStartContainer.GetValue(executionContext).AsBoolean();
                 bool useAgentNode = false;
@@ -690,17 +690,18 @@ string containerNodePath(string nodeFolder)
                                                                         dockerObject: container.ContainerImage,
                                                                         options: $"--format=\"{{{{index .Config.Labels \\\"{_nodeJsPathLabel}\\\"}}}}\"");
 
-                    if (useNodeVersionStrategy)
+                    if (useEnhancedNodeSelection)
                     {
+                        executionContext.Debug("[ContainerSetup] Using enhanced node selection path for container startup.");
                         bool isWindowsContainer = container.ImageOS == PlatformUtil.OS.Windows; 
                         
                         container.ContainerCommand = isWindowsContainer
-                            ? "cmd.exe /c timeout /t -1 /nobreak > nul"
+                            ? "cmd.exe /c ping -t localhost > nul"
                             : "sleep infinity";
                     }
                     else
                     {
-                        
+                        executionContext.Debug("[ContainerSetup] Using legacy node selection path for container startup.");
                         // Legacy approach: Use node-based startup command
                         string nodeSetInterval(string node)
                         {
@@ -814,10 +815,11 @@ string useDoubleQuotes(string value)
 
                         executionContext.Warning($"Docker container {container.ContainerId} is not in running state.");
                     }
-                    else if (useNodeVersionStrategy && container.IsJobContainer)
+                    else if (useEnhancedNodeSelection && container.IsJobContainer)
                     {
                         try
                         {
+                            executionContext.Debug("[ContainerSetup] Calling enhanced node selection path for container startup.");
                             SetContainerNodePathWithOrchestrator(executionContext, container);
                         }
                         catch (Exception ex)
diff --git a/src/Agent.Worker/Handlers/NodeHandler.cs b/src/Agent.Worker/Handlers/NodeHandler.cs
@@ -421,13 +421,15 @@ private string GetNodeFolderWithFallback(string preferredNodeFolder, bool node20
 
         public string GetNodeLocation(bool node20ResultsInGlibCError, bool node24ResultsInGlibCError, bool inContainer)
         {
-            bool useStrategyPattern = AgentKnobs.UseNodeVersionStrategy.GetValue(ExecutionContext).AsBoolean();
-
+            bool useStrategyPattern = AgentKnobs.UseEnhancedNodeSelection.GetValue(ExecutionContext).AsBoolean();
+            
             if (useStrategyPattern)
             {
+                ExecutionContext.Debug("Using enhanced node selection path for handler node resolution.");
                 return GetNodeLocationUsingStrategy(inContainer).GetAwaiter().GetResult();
             }
 
+            ExecutionContext.Debug("Using legacy node selection path for handler node resolution.");
             return GetNodeLocationLegacy(node20ResultsInGlibCError, node24ResultsInGlibCError, inContainer);
         }
 
diff --git a/src/Test/L0/NodeHandlerTestBase.cs b/src/Test/L0/NodeHandlerTestBase.cs
@@ -58,7 +58,7 @@ protected void RunScenarioAndAssert(TestScenario scenario, bool useStrategy)
                 Environment.SetEnvironmentVariable(knob.Key, knob.Value);
             }
             
-            Environment.SetEnvironmentVariable("AGENT_USE_NODE_STRATEGY", useStrategy ? "true" : "false");
+            Environment.SetEnvironmentVariable("AGENT_USE_ENHANCED_NODE_SELECTION", useStrategy ? "true" : "false");
 
             try
             {
@@ -476,7 +476,7 @@ protected void ResetEnvironment()
        
             // EOL and strategy control
             Environment.SetEnvironmentVariable("AGENT_RESTRICT_EOL_NODE_VERSIONS", null);
-            Environment.SetEnvironmentVariable("AGENT_USE_NODE_STRATEGY", null);
+            Environment.SetEnvironmentVariable("AGENT_USE_ENHANCED_NODE_SELECTION", null);
             
             // System-specific knobs
             Environment.SetEnvironmentVariable("AGENT_USE_NODE20_IN_UNSUPPORTED_SYSTEM", null);
diff --git a/src/Test/L0/Worker/ContainerOperationProviderEnhancedL0.cs b/src/Test/L0/Worker/ContainerOperationProviderEnhancedL0.cs
@@ -16,7 +16,7 @@ namespace Microsoft.VisualStudio.Services.Agent.Tests.Worker
     public sealed class ContainerOperationProviderEnhancedL0 : ContainerOperationProviderL0Base
     {
         // =============================================
-        // Legacy path tests (UseNodeVersionStrategy = false)
+        // Legacy path tests (UseEnhancedNodeSelection = false)
         // =============================================
 
         [Fact]
@@ -175,7 +175,7 @@ public async Task StartContainer_WithoutDockerLabel_OnLinux_UsesAgentNode()
         }
 
         // =============================================
-        // UseNodeVersionStrategy path tests
+        // UseEnhancedNodeSelection path tests
         // Knob activated via Moq-specific matcher overrides
         // in CreateExecutionContextMock(hc, useNodeVersionStrategy: true).
         // No env vars used — avoids parallel test pollution.
@@ -184,7 +184,7 @@ public async Task StartContainer_WithoutDockerLabel_OnLinux_UsesAgentNode()
         [Fact]
         [Trait("Level", "L0")]
         [Trait("Category", "Worker")]
-        public async Task StartContainer_UseNodeVersionStrategy_WithDockerLabel_UsesSleepOrTimeout()
+        public async Task StartContainer_UseNodeVersionStrategy_WithDockerLabel_UsesSleepOrPing()
         {
             using (var hc = new TestHostContext(this))
             {
@@ -209,7 +209,7 @@ public async Task StartContainer_UseNodeVersionStrategy_WithDockerLabel_UsesSlee
                 Assert.Equal(NodePathFromLabel, container.CustomNodePath);
                 if (PlatformUtil.RunningOnWindows)
                 {
-                    Assert.Contains("timeout", container.ContainerCommand);
+                    Assert.Contains("ping -t localhost", container.ContainerCommand);
                 }
                 else
                 {
@@ -255,7 +255,7 @@ public async Task StartContainer_UseNodeVersionStrategy_OnWindows_LinuxContainer
         [Trait("Category", "Worker")]
         [Trait("SkipOn", "darwin")]
         [Trait("SkipOn", "linux")]
-        public async Task StartContainer_UseNodeVersionStrategy_OnWindows_WindowsContainer_UsesTimeout()
+        public async Task StartContainer_UseNodeVersionStrategy_OnWindows_WindowsContainer_UsesPing()
         {
             if (!PlatformUtil.RunningOnWindows)
             {
@@ -278,7 +278,7 @@ public async Task StartContainer_UseNodeVersionStrategy_OnWindows_WindowsContain
 
                 await provider.StartContainersAsync(executionContext.Object, new List<ContainerInfo> { container });
 
-                Assert.Contains("timeout", container.ContainerCommand);
+                Assert.Contains("ping -t localhost", container.ContainerCommand);
                 Assert.Contains("nul", container.ContainerCommand);
             }
         }
diff --git a/src/Test/L0/Worker/ContainerOperationProviderL0Base.cs b/src/Test/L0/Worker/ContainerOperationProviderL0Base.cs
@@ -64,7 +64,7 @@ protected Mock<IExecutionContext> CreateExecutionContextMock(TestHostContext hc,
             executionContext.Setup(x => x.GetScopedEnvironment()).Returns(new SystemEnvironment());
 
             string knobValue = useNodeVersionStrategy ? "true" : "false";
-            executionContext.Setup(x => x.GetVariableValueOrDefault("AGENT_USE_NODE_STRATEGY")).Returns(knobValue);
+            executionContext.Setup(x => x.GetVariableValueOrDefault("AGENT_USE_ENHANCED_NODE_SELECTION")).Returns(knobValue);
 
             return executionContext;
         }

Original file line number	Diff line number	Diff line change
`@@ -553,7 +553,7 @@ private async Task StartContainerAsync(IExecutionContext executionContext, Conta`
`553`	`553`	`container.MountVolumes.Add(new MountVolume(taskKeyFile, container.TranslateToContainerPath(taskKeyFile)));`
`554`	`554`	`}`
`555`	`555`
`556`		`- bool UseNodeVersionStrategy = AgentKnobs.UseNodeVersionStrategy.GetValue(executionContext).AsBoolean();`
	`556`	`+ bool useEnhancedNodeSelection = AgentKnobs.UseEnhancedNodeSelection.GetValue(executionContext).AsBoolean();`
`557`	`557`	`bool useNode20ToStartContainer = AgentKnobs.UseNode20ToStartContainer.GetValue(executionContext).AsBoolean();`
`558`	`558`	`bool useNode24ToStartContainer = AgentKnobs.UseNode24ToStartContainer.GetValue(executionContext).AsBoolean();`
`559`	`559`	`bool useAgentNode = false;`
`@@ -581,17 +581,18 @@ string containerNodePath(string nodeFolder)`
`581`	`581`	`dockerObject: container.ContainerImage,`
`582`	`582`	`options: $"--format=\"{{{{index .Config.Labels \\\"{_nodeJsPathLabel}\\\"}}}}\"");`
`583`	`583`
`584`		`- if (UseNodeVersionStrategy)`
	`584`	`+ if (useEnhancedNodeSelection)`
`585`	`585`	`{`
	`586`	`+ executionContext.Debug("[ContainerSetup] Using enhanced node selection path for container startup.");`
`586`	`587`	`bool isWindowsContainer = container.ImageOS == PlatformUtil.OS.Windows;`
`587`	`588`
`588`	`589`	`container.ContainerCommand = isWindowsContainer`
`589`		`- ? "cmd.exe /c timeout /t -1 /nobreak > nul"`
	`590`	`+ ? "cmd.exe /c ping -t localhost > nul"`
`590`	`591`	`: "sleep infinity";`
`591`	`592`	`}`
`592`	`593`	`else`
`593`	`594`	`{`
`594`		`-`
	`595`	`+ executionContext.Debug("[ContainerSetup] Using legacy node selection path for container startup.");`
`595`	`596`	`// Legacy approach: Use node-based startup command`
`596`	`597`	`string nodeSetInterval(string node)`
`597`	`598`	`{`
`@@ -674,10 +675,11 @@ string useDoubleQuotes(string value)`
`674`	`675`
`675`	`676`	`executionContext.Warning($"Docker container {container.ContainerId} is not in running state.");`
`676`	`677`	`}`
`677`		`- else if (UseNodeVersionStrategy && container.IsJobContainer)`
	`678`	`+ else if (useEnhancedNodeSelection && container.IsJobContainer)`
`678`	`679`	`{`
`679`	`680`	`try`
`680`	`681`	`{`
	`682`	`+ executionContext.Debug("[ContainerSetup] Calling enhanced node selection path for container startup.");`
`681`	`683`	`SetContainerNodePathWithOrchestrator(executionContext, container);`
`682`	`684`	`}`
`683`	`685`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -662,7 +662,7 @@ private async Task StartContainerAsync(IExecutionContext executionContext, Conta`
`662`	`662`	`$"{m.SourceVolumePath ?? "anonymous"}:{m.TargetVolumePath}{(m.ReadOnly ? ":ro" : "")}");`
`663`	`663`	`trace.Info($"Configured {container.MountVolumes.Count} volume mounts: {string.Join(", ", mountSummary)}");`
`664`	`664`
`665`		`- bool useNodeVersionStrategy = AgentKnobs.UseNodeVersionStrategy.GetValue(executionContext).AsBoolean();`
	`665`	`+ bool useEnhancedNodeSelection = AgentKnobs.UseEnhancedNodeSelection.GetValue(executionContext).AsBoolean();`
`666`	`666`	`bool useNode20ToStartContainer = AgentKnobs.UseNode20ToStartContainer.GetValue(executionContext).AsBoolean();`
`667`	`667`	`bool useNode24ToStartContainer = AgentKnobs.UseNode24ToStartContainer.GetValue(executionContext).AsBoolean();`
`668`	`668`	`bool useAgentNode = false;`
`@@ -690,17 +690,18 @@ string containerNodePath(string nodeFolder)`
`690`	`690`	`dockerObject: container.ContainerImage,`
`691`	`691`	`options: $"--format=\"{{{{index .Config.Labels \\\"{_nodeJsPathLabel}\\\"}}}}\"");`
`692`	`692`
`693`		`- if (useNodeVersionStrategy)`
	`693`	`+ if (useEnhancedNodeSelection)`
`694`	`694`	`{`
	`695`	`+ executionContext.Debug("[ContainerSetup] Using enhanced node selection path for container startup.");`
`695`	`696`	`bool isWindowsContainer = container.ImageOS == PlatformUtil.OS.Windows;`
`696`	`697`
`697`	`698`	`container.ContainerCommand = isWindowsContainer`
`698`		`- ? "cmd.exe /c timeout /t -1 /nobreak > nul"`
	`699`	`+ ? "cmd.exe /c ping -t localhost > nul"`
`699`	`700`	`: "sleep infinity";`
`700`	`701`	`}`
`701`	`702`	`else`
`702`	`703`	`{`
`703`		`-`
	`704`	`+ executionContext.Debug("[ContainerSetup] Using legacy node selection path for container startup.");`
`704`	`705`	`// Legacy approach: Use node-based startup command`
`705`	`706`	`string nodeSetInterval(string node)`
`706`	`707`	`{`
`@@ -814,10 +815,11 @@ string useDoubleQuotes(string value)`
`814`	`815`
`815`	`816`	`executionContext.Warning($"Docker container {container.ContainerId} is not in running state.");`
`816`	`817`	`}`
`817`		`- else if (useNodeVersionStrategy && container.IsJobContainer)`
	`818`	`+ else if (useEnhancedNodeSelection && container.IsJobContainer)`
`818`	`819`	`{`
`819`	`820`	`try`
`820`	`821`	`{`
	`822`	`+ executionContext.Debug("[ContainerSetup] Calling enhanced node selection path for container startup.");`
`821`	`823`	`SetContainerNodePathWithOrchestrator(executionContext, container);`
`822`	`824`	`}`
`823`	`825`	`catch (Exception ex)`
Original file line number	Diff line number	Diff line change
`@@ -421,13 +421,15 @@ private string GetNodeFolderWithFallback(string preferredNodeFolder, bool node20`
`421`	`421`
`422`	`422`	`public string GetNodeLocation(bool node20ResultsInGlibCError, bool node24ResultsInGlibCError, bool inContainer)`
`423`	`423`	`{`
`424`		`- bool useStrategyPattern = AgentKnobs.UseNodeVersionStrategy.GetValue(ExecutionContext).AsBoolean();`
`425`		`-`
	`424`	`+ bool useStrategyPattern = AgentKnobs.UseEnhancedNodeSelection.GetValue(ExecutionContext).AsBoolean();`
	`425`	`+`
`426`	`426`	`if (useStrategyPattern)`
`427`	`427`	`{`
	`428`	`+ ExecutionContext.Debug("Using enhanced node selection path for handler node resolution.");`
`428`	`429`	`return GetNodeLocationUsingStrategy(inContainer).GetAwaiter().GetResult();`
`429`	`430`	`}`
`430`	`431`
	`432`	`+ ExecutionContext.Debug("Using legacy node selection path for handler node resolution.");`
`431`	`433`	`return GetNodeLocationLegacy(node20ResultsInGlibCError, node24ResultsInGlibCError, inContainer);`
`432`	`434`	`}`
`433`	`435`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ protected void RunScenarioAndAssert(TestScenario scenario, bool useStrategy)`
`58`	`58`	`Environment.SetEnvironmentVariable(knob.Key, knob.Value);`
`59`	`59`	`}`
`60`	`60`
`61`		`- Environment.SetEnvironmentVariable("AGENT_USE_NODE_STRATEGY", useStrategy ? "true" : "false");`
	`61`	`+ Environment.SetEnvironmentVariable("AGENT_USE_ENHANCED_NODE_SELECTION", useStrategy ? "true" : "false");`
`62`	`62`
`63`	`63`	`try`
`64`	`64`	`{`
`@@ -476,7 +476,7 @@ protected void ResetEnvironment()`
`476`	`476`
`477`	`477`	`// EOL and strategy control`
`478`	`478`	`Environment.SetEnvironmentVariable("AGENT_RESTRICT_EOL_NODE_VERSIONS", null);`
`479`		`- Environment.SetEnvironmentVariable("AGENT_USE_NODE_STRATEGY", null);`
	`479`	`+ Environment.SetEnvironmentVariable("AGENT_USE_ENHANCED_NODE_SELECTION", null);`
`480`	`480`
`481`	`481`	`// System-specific knobs`
`482`	`482`	`Environment.SetEnvironmentVariable("AGENT_USE_NODE20_IN_UNSUPPORTED_SYSTEM", null);`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ namespace Microsoft.VisualStudio.Services.Agent.Tests.Worker`
`16`	`16`	`public sealed class ContainerOperationProviderEnhancedL0 : ContainerOperationProviderL0Base`
`17`	`17`	`{`
`18`	`18`	`// =============================================`
`19`		`- // Legacy path tests (UseNodeVersionStrategy = false)`
	`19`	`+ // Legacy path tests (UseEnhancedNodeSelection = false)`
`20`	`20`	`// =============================================`
`21`	`21`
`22`	`22`	`[Fact]`
`@@ -175,7 +175,7 @@ public async Task StartContainer_WithoutDockerLabel_OnLinux_UsesAgentNode()`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	`// =============================================`
`178`		`- // UseNodeVersionStrategy path tests`
	`178`	`+ // UseEnhancedNodeSelection path tests`
`179`	`179`	`// Knob activated via Moq-specific matcher overrides`
`180`	`180`	`// in CreateExecutionContextMock(hc, useNodeVersionStrategy: true).`
`181`	`181`	`// No env vars used — avoids parallel test pollution.`
`@@ -184,7 +184,7 @@ public async Task StartContainer_WithoutDockerLabel_OnLinux_UsesAgentNode()`
`184`	`184`	`[Fact]`
`185`	`185`	`[Trait("Level", "L0")]`
`186`	`186`	`[Trait("Category", "Worker")]`
`187`		`- public async Task StartContainer_UseNodeVersionStrategy_WithDockerLabel_UsesSleepOrTimeout()`
	`187`	`+ public async Task StartContainer_UseNodeVersionStrategy_WithDockerLabel_UsesSleepOrPing()`
`188`	`188`	`{`
`189`	`189`	`using (var hc = new TestHostContext(this))`
`190`	`190`	`{`
`@@ -209,7 +209,7 @@ public async Task StartContainer_UseNodeVersionStrategy_WithDockerLabel_UsesSlee`
`209`	`209`	`Assert.Equal(NodePathFromLabel, container.CustomNodePath);`
`210`	`210`	`if (PlatformUtil.RunningOnWindows)`
`211`	`211`	`{`
`212`		`- Assert.Contains("timeout", container.ContainerCommand);`
	`212`	`+ Assert.Contains("ping -t localhost", container.ContainerCommand);`
`213`	`213`	`}`
`214`	`214`	`else`
`215`	`215`	`{`
`@@ -255,7 +255,7 @@ public async Task StartContainer_UseNodeVersionStrategy_OnWindows_LinuxContainer`
`255`	`255`	`[Trait("Category", "Worker")]`
`256`	`256`	`[Trait("SkipOn", "darwin")]`
`257`	`257`	`[Trait("SkipOn", "linux")]`
`258`		`- public async Task StartContainer_UseNodeVersionStrategy_OnWindows_WindowsContainer_UsesTimeout()`
	`258`	`+ public async Task StartContainer_UseNodeVersionStrategy_OnWindows_WindowsContainer_UsesPing()`
`259`	`259`	`{`
`260`	`260`	`if (!PlatformUtil.RunningOnWindows)`
`261`	`261`	`{`
`@@ -278,7 +278,7 @@ public async Task StartContainer_UseNodeVersionStrategy_OnWindows_WindowsContain`
`278`	`278`
`279`	`279`	`await provider.StartContainersAsync(executionContext.Object, new List<ContainerInfo> { container });`
`280`	`280`
`281`		`- Assert.Contains("timeout", container.ContainerCommand);`
	`281`	`+ Assert.Contains("ping -t localhost", container.ContainerCommand);`
`282`	`282`	`Assert.Contains("nul", container.ContainerCommand);`
`283`	`283`	`}`
`284`	`284`	`}`
Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,7 @@ protected Mock<IExecutionContext> CreateExecutionContextMock(TestHostContext hc,`
`64`	`64`	`executionContext.Setup(x => x.GetScopedEnvironment()).Returns(new SystemEnvironment());`
`65`	`65`
`66`	`66`	`string knobValue = useNodeVersionStrategy ? "true" : "false";`
`67`		`- executionContext.Setup(x => x.GetVariableValueOrDefault("AGENT_USE_NODE_STRATEGY")).Returns(knobValue);`
	`67`	`+ executionContext.Setup(x => x.GetVariableValueOrDefault("AGENT_USE_ENHANCED_NODE_SELECTION")).Returns(knobValue);`
`68`	`68`
`69`	`69`	`return executionContext;`
`70`	`70`	`}`