release 2.165.2 runner

This reverts commit c45aebc9ab.

.github/workflows/release.yml

@@ -70,7 +70,15 @@ jobs:
 
     runs-on: ${{ matrix.os }}
     steps:
-    - uses: actions/checkout@v1
+    - uses: actions/checkout@v2
+
+    # Set Path workaround for https://github.com/actions/virtual-environments/issues/263
+    - run: |
+        echo "::add-path::C:\Program Files\Git\mingw64\bin"
+        echo "::add-path::C:\Program Files\Git\usr\bin"
+        echo "::add-path::C:\Program Files\Git\bin"
+      if: matrix.os == 'windows-latest'
+      name: "Temp step to Set Path for Windows"
 
     # Build runner layout
     - name: Build & Layout Release

releaseNote.md

@@ -17,7 +17,6 @@
   - Trace javascript action exit code to debug instead of user logs (#290)
   - Change prompt message when removing a runner to lines up with GitHub.com UI (#303) 
   - Include step.env as part of env context. (#300)
-  - Update Base64 Encoders to deal with suffixes (#284)
 
 ## Misc
   - Move .sln file under ./src (#238)

releaseVersion

@@ -1 +1 @@
-2.164.0
+2.165.2

src/Runner.Common/HostContext.cs

@@ -83,7 +83,6 @@ namespace GitHub.Runner.Common
             _loadContext.Unloading += LoadContext_Unloading;
 
             this.SecretMasker.AddValueEncoder(ValueEncoders.Base64StringEscape);
-            this.SecretMasker.AddValueEncoder(ValueEncoders.Base64StringEscapeTrimmed);
             this.SecretMasker.AddValueEncoder(ValueEncoders.Base64StringEscapeShift1);
             this.SecretMasker.AddValueEncoder(ValueEncoders.Base64StringEscapeShift2);
             this.SecretMasker.AddValueEncoder(ValueEncoders.ExpressionStringEscape);

src/Runner.Worker/StepsRunner.cs

@@ -76,6 +76,9 @@ namespace GitHub.Runner.Worker
                 // Start
                 step.ExecutionContext.Start();
 
+                // Initialize scope
+                if (InitializeScope(step, scopeInputs))
+                {
                     // Populate env context for each step
                     Trace.Info("Initialize Env context for step");
 #if OS_WINDOWS
@@ -105,9 +108,6 @@ namespace GitHub.Runner.Worker
                         }
                     }
 
-                // Initialize scope
-                if (InitializeScope(step, scopeInputs))
-                {
                     var expressionManager = HostContext.GetService<IExpressionManager>();
                     try
                     {

src/Sdk/DTLogging/Logging/ValueEncoders.cs

@@ -17,11 +17,6 @@ namespace GitHub.DistributedTask.Logging
             return Convert.ToBase64String(Encoding.UTF8.GetBytes(value));
         }
 
-        public static String Base64StringEscapeTrimmed(String value)
-        {
-            return TrimBase64End(Convert.ToBase64String(Encoding.UTF8.GetBytes(value)));
-        }
-
         // Base64 is 6 bits -> char
         // A byte is 8 bits
         // When end user doing somthing like base64(user:password)
@@ -72,15 +67,15 @@ namespace GitHub.DistributedTask.Logging
             {
                 var shiftArray = new byte[bytes.Length - shift];
                 Array.Copy(bytes, shift, shiftArray, 0, bytes.Length - shift);
-                return TrimBase64End(Convert.ToBase64String(shiftArray));
+                return Convert.ToBase64String(shiftArray);
             }
             else
             {
-                return TrimBase64End(Convert.ToBase64String(bytes));
+                return Convert.ToBase64String(bytes);
             }
         }
 
-        public static String UriDataEscape(
+        private static String UriDataEscape(
             String value,
             Int32 maxSegmentSize)
         {
@@ -108,26 +103,5 @@ namespace GitHub.DistributedTask.Logging
 
             return result.ToString();
         }
-
-        private static String TrimBase64End(String value)
-        {
-            if (String.IsNullOrEmpty(value))
-            {
-                return String.Empty;
-            }
-            if (value.EndsWith('='))
-            {
-                var trimmed = value.TrimEnd('=');
-                if (trimmed.Length > 1)
-                {
-                    // If a base64 string ends in '=' it indicates that the base 64 character is only using 2 or 4 of the six bytes and will change if another character is added
-                    // For example 'ab' is 'YWI=' in base 64
-                    // 'abc' is 'YWJj'
-                    // We need to detect YW, not YWI so we trim the last character ('I')
-                    return trimmed.Substring(0, trimmed.Length - 1);
-                }
-            }
-            return value;
-        }
     }
 }

src/Test/L0/HostContextL0.cs

@@ -93,21 +93,12 @@ namespace GitHub.Runner.Common.Tests
                 Assert.Equal("123***123", _hc.SecretMasker.MaskSecrets("123Pass%20word%20123%21123"));
                 Assert.Equal("123***123", _hc.SecretMasker.MaskSecrets("123Pass<word>123!123"));
                 Assert.Equal("123***123", _hc.SecretMasker.MaskSecrets("123Pass''word''123!123"));
-                Assert.Equal("OlBh***Q==", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($":Password123!"))));
-                Assert.Equal("YTpQ***E=", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"a:Password123!"))));
+                Assert.Equal("OlBh***", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($":Password123!"))));
+                Assert.Equal("YTpQ***", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"a:Password123!"))));
                 Assert.Equal("YWI6***", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"ab:Password123!"))));
-                Assert.Equal("YWJjOlBh***Q==", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"abc:Password123!"))));
-                Assert.Equal("YWJjZDpQ***E=", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"abcd:Password123!"))));
+                Assert.Equal("YWJjOlBh***", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"abc:Password123!"))));
+                Assert.Equal("YWJjZDpQ***", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"abcd:Password123!"))));
                 Assert.Equal("YWJjZGU6***", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"abcde:Password123!"))));
-                Assert.Equal("***Og==", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"Password123!:"))));
-                Assert.Equal("***OmE=", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"Password123!:a"))));
-                Assert.Equal("***OmFi", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"Password123!:ab"))));
-                Assert.Equal("***OmFiYw==", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"Password123!:abc"))));
-                Assert.Equal("***OmFiY2Q=", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"Password123!:abcd"))));
-                Assert.Equal("***OmFiY2Rl", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"Password123!:abcde"))));
-                Assert.Equal("OlBh***To=", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($":Password123!:"))));
-                Assert.Equal("YTpQ***E6YQ==", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"a:Password123!:a"))));
-                Assert.Equal("YWJjOlBh***Tph", _hc.SecretMasker.MaskSecrets(Convert.ToBase64String(Encoding.UTF8.GetBytes($"abc:Password123!:a"))));
             }
             finally
             {

src/Test/L0/Worker/StepsRunnerL0.cs

@@ -70,9 +70,9 @@ namespace GitHub.Runner.Common.Tests.Worker
                 // Arrange.
                 var variableSets = new[]
                 {
-                    new[] { CreateStep(TaskResult.Succeeded, "success()"), CreateStep(TaskResult.Succeeded, "success()")  },
-                    new[] { CreateStep(TaskResult.Succeeded, "success()"), CreateStep(TaskResult.Succeeded, "success() || failure()") },
-                    new[] { CreateStep(TaskResult.Succeeded, "success()"), CreateStep(TaskResult.Succeeded, "always()") }
+                    new[] { CreateStep(hc, TaskResult.Succeeded, "success()"), CreateStep(hc, TaskResult.Succeeded, "success()")  },
+                    new[] { CreateStep(hc, TaskResult.Succeeded, "success()"), CreateStep(hc, TaskResult.Succeeded, "success() || failure()") },
+                    new[] { CreateStep(hc, TaskResult.Succeeded, "success()"), CreateStep(hc, TaskResult.Succeeded, "always()") }
                 };
                 foreach (var variableSet in variableSets)
                 {
@@ -102,12 +102,12 @@ namespace GitHub.Runner.Common.Tests.Worker
                 // Arrange.
                 var variableSets = new[]
                 {
-                    new[] { CreateStep(TaskResult.Failed, "success()", true), CreateStep(TaskResult.Succeeded, "success()")  },
-                    new[] { CreateStep(TaskResult.Failed, "success()", true), CreateStep(TaskResult.Succeeded, "success() || failure()") },
-                    new[] { CreateStep(TaskResult.Failed, "success()", true), CreateStep(TaskResult.Succeeded, "always()") },
-                    new[] { CreateStep(TaskResult.Failed, "success()", true), CreateStep(TaskResult.Failed, "success()", true)  },
-                    new[] { CreateStep(TaskResult.Failed, "success()", true), CreateStep(TaskResult.Failed, "success() || failure()", true) },
-                    new[] { CreateStep(TaskResult.Failed, "success()", true), CreateStep(TaskResult.Failed, "always()", true) }
+                    new[] { CreateStep(hc, TaskResult.Failed, "success()", true), CreateStep(hc, TaskResult.Succeeded, "success()")  },
+                    new[] { CreateStep(hc, TaskResult.Failed, "success()", true), CreateStep(hc, TaskResult.Succeeded, "success() || failure()") },
+                    new[] { CreateStep(hc, TaskResult.Failed, "success()", true), CreateStep(hc, TaskResult.Succeeded, "always()") },
+                    new[] { CreateStep(hc, TaskResult.Failed, "success()", true), CreateStep(hc, TaskResult.Failed, "success()", true)  },
+                    new[] { CreateStep(hc, TaskResult.Failed, "success()", true), CreateStep(hc, TaskResult.Failed, "success() || failure()", true) },
+                    new[] { CreateStep(hc, TaskResult.Failed, "success()", true), CreateStep(hc, TaskResult.Failed, "always()", true) }
                 };
                 foreach (var variableSet in variableSets)
                 {
@@ -139,12 +139,12 @@ namespace GitHub.Runner.Common.Tests.Worker
                 {
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "success()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "success()") },
                         Expected = false,
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "success() || failure()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "success() || failure()") },
                         Expected = true,
                     },
                 };
@@ -178,27 +178,27 @@ namespace GitHub.Runner.Common.Tests.Worker
                 {
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Succeeded, "success()"), CreateStep(TaskResult.Succeeded, "always()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Succeeded, "success()"), CreateStep(hc, TaskResult.Succeeded, "always()") },
                         Expected = TaskResult.Succeeded,
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "always()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "always()") },
                         Expected = TaskResult.Failed,
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "always()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "always()") },
                         Expected = TaskResult.Failed,
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Succeeded, "success()"), CreateStep(TaskResult.Failed, "always()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Succeeded, "success()"), CreateStep(hc, TaskResult.Failed, "always()") },
                         Expected = TaskResult.Failed,
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Succeeded, "success()"), CreateStep(TaskResult.Failed, "always()", true) },
+                        Steps = new[] { CreateStep(hc, TaskResult.Succeeded, "success()"), CreateStep(hc, TaskResult.Failed, "always()", true) },
                         Expected = TaskResult.Succeeded,
                     },
                 };
@@ -232,47 +232,47 @@ namespace GitHub.Runner.Common.Tests.Worker
                 {
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "success()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "success()") },
                         Expected = TaskResult.Failed
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "success() || failure()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "success() || failure()") },
                         Expected = TaskResult.Failed
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "always()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "always()") },
                         Expected = TaskResult.Failed
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()", continueOnError: true), CreateStep(TaskResult.Failed, "success()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()", continueOnError: true), CreateStep(hc, TaskResult.Failed, "success()") },
                         Expected = TaskResult.Failed
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()", continueOnError: true), CreateStep(TaskResult.Succeeded, "success()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()", continueOnError: true), CreateStep(hc, TaskResult.Succeeded, "success()") },
                         Expected = TaskResult.Succeeded
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Failed, "success()", continueOnError: true), CreateStep(TaskResult.Failed, "success()", continueOnError: true) },
+                        Steps = new[] { CreateStep(hc, TaskResult.Failed, "success()", continueOnError: true), CreateStep(hc, TaskResult.Failed, "success()", continueOnError: true) },
                         Expected = TaskResult.Succeeded
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Succeeded, "success() || failure()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Succeeded, "success() || failure()") },
                         Expected = TaskResult.Succeeded
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Succeeded, "success()"), CreateStep(TaskResult.Failed, "success()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Succeeded, "success()"), CreateStep(hc, TaskResult.Failed, "success()") },
                         Expected = TaskResult.Failed
                     },
                     new
                     {
-                        Steps = new[] { CreateStep(TaskResult.Succeeded, "success()"), CreateStep(TaskResult.Succeeded, "success()") },
+                        Steps = new[] { CreateStep(hc, TaskResult.Succeeded, "success()"), CreateStep(hc, TaskResult.Succeeded, "success()") },
                         Expected = TaskResult.Succeeded
                     },
                 //  Abandoned
@@ -310,17 +310,17 @@ namespace GitHub.Runner.Common.Tests.Worker
                 {
                     new
                     {
-                        Step = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "success()") },
+                        Step = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "success()") },
                         Expected = false
                     },
                     new
                     {
-                        Step = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "success() || failure()") },
+                        Step = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "success() || failure()") },
                         Expected = true
                     },
                     new
                     {
-                        Step = new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "always()") },
+                        Step = new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "always()") },
                         Expected = true
                     }
                 };
@@ -351,9 +351,9 @@ namespace GitHub.Runner.Common.Tests.Worker
                 // Arrange.
                 var variableSets = new[]
                 {
-                    new[] { CreateStep(TaskResult.Succeeded, "success()"), CreateStep(TaskResult.Succeeded, "always()") },
-                    new[] { CreateStep(TaskResult.Failed, "success()"), CreateStep(TaskResult.Succeeded, "always()") },
-                    new[] { CreateStep(TaskResult.Canceled, "success()"), CreateStep(TaskResult.Succeeded, "always()") }
+                    new[] { CreateStep(hc, TaskResult.Succeeded, "success()"), CreateStep(hc, TaskResult.Succeeded, "always()") },
+                    new[] { CreateStep(hc, TaskResult.Failed, "success()"), CreateStep(hc, TaskResult.Succeeded, "always()") },
+                    new[] { CreateStep(hc, TaskResult.Canceled, "success()"), CreateStep(hc, TaskResult.Succeeded, "always()") }
                 };
                 foreach (var variableSet in variableSets)
                 {
@@ -387,8 +387,8 @@ namespace GitHub.Runner.Common.Tests.Worker
                 // Arrange.
                 var variableSets = new[]
                 {
-                    new[] { CreateStep(TaskResult.Succeeded, "success()") },
-                    new[] { CreateStep(TaskResult.Succeeded, "success()") },
+                    new[] { CreateStep(hc, TaskResult.Succeeded, "success()") },
+                    new[] { CreateStep(hc, TaskResult.Succeeded, "success()") },
                 };
                 foreach (var variableSet in variableSets)
                 {
@@ -416,7 +416,7 @@ namespace GitHub.Runner.Common.Tests.Worker
                 var env1 = new MappingToken(null, null, null);
                 env1.Add(new StringToken(null, null, null, "env1"), new StringToken(null, null, null, "100"));
                 env1.Add(new StringToken(null, null, null, "env2"), new BasicExpressionToken(null, null, null, "env.test"));
-                var step1 = CreateStep(TaskResult.Succeeded, "success()", env: env1);
+                var step1 = CreateStep(hc, TaskResult.Succeeded, "success()", env: env1);
 
                 _ec.Object.Result = null;
 
@@ -449,12 +449,12 @@ namespace GitHub.Runner.Common.Tests.Worker
                 var env1 = new MappingToken(null, null, null);
                 env1.Add(new StringToken(null, null, null, "env1"), new StringToken(null, null, null, "100"));
                 env1.Add(new StringToken(null, null, null, "env2"), new BasicExpressionToken(null, null, null, "env.test"));
-                var step1 = CreateStep(TaskResult.Succeeded, "success()", env: env1);
+                var step1 = CreateStep(hc, TaskResult.Succeeded, "success()", env: env1);
 
                 var env2 = new MappingToken(null, null, null);
                 env2.Add(new StringToken(null, null, null, "env1"), new StringToken(null, null, null, "1000"));
                 env2.Add(new StringToken(null, null, null, "env3"), new BasicExpressionToken(null, null, null, "env.test"));
-                var step2 = CreateStep(TaskResult.Succeeded, "success()", env: env2);
+                var step2 = CreateStep(hc, TaskResult.Succeeded, "success()", env: env2);
 
                 _ec.Object.Result = null;
 
@@ -477,17 +477,52 @@ namespace GitHub.Runner.Common.Tests.Worker
             }
         }
 
-        private Mock<IActionRunner> CreateStep(TaskResult result, string condition, Boolean continueOnError = false, MappingToken env = null)
+        [Fact]
+        [Trait("Level", "L0")]
+        [Trait("Category", "Worker")]
+        public async Task PopulateEnvContextAfterSetupStepsContext()
+        {
+            using (TestHostContext hc = CreateTestContext())
+            {
+                // Arrange.
+                var env1 = new MappingToken(null, null, null);
+                env1.Add(new StringToken(null, null, null, "env1"), new StringToken(null, null, null, "100"));
+                var step1 = CreateStep(hc, TaskResult.Succeeded, "success()", env: env1, name: "foo", setOutput: true);
+
+                var env2 = new MappingToken(null, null, null);
+                env2.Add(new StringToken(null, null, null, "env1"), new StringToken(null, null, null, "1000"));
+                env2.Add(new StringToken(null, null, null, "env2"), new BasicExpressionToken(null, null, null, "steps.foo.outputs.test"));
+                var step2 = CreateStep(hc, TaskResult.Succeeded, "success()", env: env2);
+
+                _ec.Object.Result = null;
+
+                _ec.Setup(x => x.JobSteps).Returns(new Queue<IStep>(new[] { step1.Object, step2.Object }));
+
+                // Act.
+                await _stepsRunner.RunAsync(jobContext: _ec.Object);
+
+                // Assert.
+                Assert.Equal(TaskResult.Succeeded, _ec.Object.Result ?? TaskResult.Succeeded);
+#if OS_WINDOWS
+                Assert.Equal("1000", _ec.Object.ExpressionValues["env"].AssertDictionary("env")["env1"].AssertString("1000"));
+                Assert.Equal("something", _ec.Object.ExpressionValues["env"].AssertDictionary("env")["env2"].AssertString("something"));
+#else
+                Assert.Equal("1000", _ec.Object.ExpressionValues["env"].AssertCaseSensitiveDictionary("env")["env1"].AssertString("1000"));
+                Assert.Equal("something", _ec.Object.ExpressionValues["env"].AssertCaseSensitiveDictionary("env")["env2"].AssertString("something"));
+#endif
+            }
+        }
+
+        private Mock<IActionRunner> CreateStep(TestHostContext hc, TaskResult result, string condition, Boolean continueOnError = false, MappingToken env = null, string name = "Test", bool setOutput = false)
         {
             // Setup the step.
             var step = new Mock<IActionRunner>();
             step.Setup(x => x.Condition).Returns(condition);
             step.Setup(x => x.ContinueOnError).Returns(new BooleanToken(null, null, null, continueOnError));
-            step.Setup(x => x.RunAsync()).Returns(Task.CompletedTask);
             step.Setup(x => x.Action)
                 .Returns(new DistributedTask.Pipelines.ActionStep()
                 {
-                    Name = "Test",
+                    Name = name,
                     Id = Guid.NewGuid(),
                     Environment = env
                 });
@@ -495,6 +530,7 @@ namespace GitHub.Runner.Common.Tests.Worker
             // Setup the step execution context.
             var stepContext = new Mock<IExecutionContext>();
             stepContext.SetupAllProperties();
+            stepContext.Setup(x => x.WriteDebug).Returns(true);
             stepContext.Setup(x => x.Variables).Returns(_variables);
             stepContext.Setup(x => x.EnvironmentVariables).Returns(_env);
             stepContext.Setup(x => x.ExpressionValues).Returns(_contexts);
@@ -508,9 +544,20 @@ namespace GitHub.Runner.Common.Tests.Worker
                         stepContext.Object.Result = r;
                     }
                 });
+            var trace = hc.GetTrace();
+            stepContext.Setup(x => x.Write(It.IsAny<string>(), It.IsAny<string>())).Callback((string tag, string message) => { trace.Info($"[{tag}]{message}"); });
             stepContext.Object.Result = result;
             step.Setup(x => x.ExecutionContext).Returns(stepContext.Object);
 
+            if (setOutput)
+            {
+                step.Setup(x => x.RunAsync()).Callback(() => { _stepContext.SetOutput(null, name, "test", "something", out string reference); }).Returns(Task.CompletedTask);
+            }
+            else
+            {
+                step.Setup(x => x.RunAsync()).Returns(Task.CompletedTask);
+            }
+
             return step;
         }
 

src/runnerversion

@@ -1 +1 @@
-2.165.0
+2.165.2