Experimentally revert "Make Project actions self-checking (#44032)" to see if this fixes the new template test errorsstevesa/rollback-sdk

This reverts commit 2f67164b902331462284c670bba62014be5c8f60.

16 files changed, 145 insertions, 82 deletions

diff --git a/src/ProjectTemplates/Shared/BlazorTemplateTest.cs b/src/ProjectTemplates/Shared/BlazorTemplateTest.cs
index 26e4ef47a6..745df0197d 100644
--- a/src/ProjectTemplates/Shared/BlazorTemplateTest.cs
+++ b/src/ProjectTemplates/Shared/BlazorTemplateTest.cs
@@ -52,7 +52,8 @@ public abstract class BlazorTemplateTest : LoggedTest
             project.TargetFramework = targetFramework;
         }
 
-        await project.RunDotNetNewAsync(ProjectType, auth: auth, args: args, errorOnRestoreError: false);
+        var createResult = await project.RunDotNetNewAsync(ProjectType, auth: auth, args: args, errorOnRestoreError: false);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         if (serverProject || auth is null)
         {
@@ -77,7 +78,8 @@ public abstract class BlazorTemplateTest : LoggedTest
                 targetProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server");
             }
 
-            await targetProject.RunDotNetPublishAsync(noRestore: false);
+            var publishResult = await targetProject.RunDotNetPublishAsync(noRestore: false);
+            Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", targetProject, publishResult));
         }
 
         return project;
diff --git a/src/ProjectTemplates/Shared/Project.cs b/src/ProjectTemplates/Shared/Project.cs
index 7fd72f88fe..0fe3631e56 100644
--- a/src/ProjectTemplates/Shared/Project.cs
+++ b/src/ProjectTemplates/Shared/Project.cs
@@ -61,7 +61,7 @@ public class Project : IDisposable
     public ITestOutputHelper Output { get; set; }
     public IMessageSink DiagnosticsMessageSink { get; set; }
 
-    internal async Task RunDotNetNewAsync(
+    internal async Task<ProcessResult> RunDotNetNewAsync(
         string templateName,
         string auth = null,
         string language = null,
@@ -126,10 +126,10 @@ public class Project : IDisposable
             result.ExitCode = -1;
         }
 
-        Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", this, result));
+        return result;
     }
 
-    internal async Task RunDotNetPublishAsync(IDictionary<string, string> packageOptions = null, string additionalArgs = null, bool noRestore = true)
+    internal async Task<ProcessResult> RunDotNetPublishAsync(IDictionary<string, string> packageOptions = null, string additionalArgs = null, bool noRestore = true)
     {
         Output.WriteLine("Publishing ASP.NET Core application...");
 
@@ -150,11 +150,10 @@ public class Project : IDisposable
         }
 
         CaptureBinLogOnFailure(execution);
-
-        Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", this, result));
+        return result;
     }
 
-    internal async Task RunDotNetBuildAsync(IDictionary<string, string> packageOptions = null, string additionalArgs = null, bool errorOnBuildWarning = true)
+    internal async Task<ProcessResult> RunDotNetBuildAsync(IDictionary<string, string> packageOptions = null, string additionalArgs = null, bool errorOnBuildWarning = true)
     {
         Output.WriteLine("Building ASP.NET Core application...");
 
@@ -173,8 +172,7 @@ public class Project : IDisposable
         }
 
         CaptureBinLogOnFailure(execution);
-
-        Assert.True(0 == result.ExitCode, ErrorMessages.GetFailedProcessMessage("build", this, result));
+        return result;
     }
 
     internal AspNetProcess StartBuiltProjectAsync(bool hasListeningUri = true, ILogger logger = null)
@@ -208,7 +206,7 @@ public class Project : IDisposable
         return new AspNetProcess(DevCert, Output, TemplatePublishDir, projectDll, environment, published: true, hasListeningUri: hasListeningUri, usePublishedAppHost: usePublishedAppHost);
     }
 
-    internal async Task RunDotNetEfCreateMigrationAsync(string migrationName)
+    internal async Task<ProcessResult> RunDotNetEfCreateMigrationAsync(string migrationName)
     {
         var args = $"--verbose --no-build migrations add {migrationName}";
 
@@ -224,11 +222,10 @@ public class Project : IDisposable
 
         using var result = ProcessEx.Run(Output, TemplateOutputDir, command, args);
         await result.Exited;
-        var processResult = new ProcessResult(result);
-        Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", this, processResult));
+        return new ProcessResult(result);
     }
 
-    internal async Task RunDotNetEfUpdateDatabaseAsync()
+    internal async Task<ProcessResult> RunDotNetEfUpdateDatabaseAsync()
     {
         var args = "--verbose --no-build database update";
 
@@ -244,8 +241,7 @@ public class Project : IDisposable
 
         using var result = ProcessEx.Run(Output, TemplateOutputDir, command, args);
         await result.Exited;
-        var processResult = new ProcessResult(result);
-        Assert.True(0 == processResult.ExitCode, ErrorMessages.GetFailedProcessMessage("update database", this, processResult));
+        return new ProcessResult(result);
     }
 
     // If this fails, you should generate new migrations via migrations/updateMigrations.cmd
@@ -293,7 +289,7 @@ public class Project : IDisposable
         }
     }
 
-    public async Task VerifyLaunchSettings(string[] expectedLaunchProfileNames)
+    public async Task<Project> VerifyLaunchSettings(string[] expectedLaunchProfileNames)
     {
         var launchSettingsFiles = Directory.EnumerateFiles(TemplateOutputDir, "launchSettings.json", SearchOption.AllDirectories);
 
@@ -346,6 +342,8 @@ public class Project : IDisposable
                 }
             }
         }
+
+        return this;
     }
 
     public string ReadFile(string path)
@@ -354,7 +352,7 @@ public class Project : IDisposable
         return File.ReadAllText(Path.Combine(TemplateOutputDir, path));
     }
 
-    internal async Task RunDotNetNewRawAsync(string arguments)
+    internal async Task<ProcessEx> RunDotNetNewRawAsync(string arguments)
     {
         var result = ProcessEx.Run(
             Output,
@@ -364,7 +362,7 @@ public class Project : IDisposable
                 $" --debug:disable-sdk-templates --debug:custom-hive \"{TemplatePackageInstaller.CustomHivePath}\"" +
                 $" -o {TemplateOutputDir}");
         await result.Exited;
-        Assert.True(result.ExitCode == 0, result.GetFormattedOutput());
+        return result;
     }
 
     public void Dispose()
diff --git a/src/ProjectTemplates/test/Templates.Blazor.Tests/BlazorTemplateTest.cs b/src/ProjectTemplates/test/Templates.Blazor.Tests/BlazorTemplateTest.cs
index d8fa6d3d8e..8ea4077007 100644
--- a/src/ProjectTemplates/test/Templates.Blazor.Tests/BlazorTemplateTest.cs
+++ b/src/ProjectTemplates/test/Templates.Blazor.Tests/BlazorTemplateTest.cs
@@ -35,7 +35,8 @@ public abstract class BlazorTemplateTest : BrowserTestBase
             project.TargetFramework = targetFramework;
         }
 
-        await project.RunDotNetNewAsync(ProjectType, auth: auth, args: args);
+        var createResult = await project.RunDotNetNewAsync(ProjectType, auth: auth, args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         if (!onlyCreate)
         {
@@ -45,13 +46,15 @@ public abstract class BlazorTemplateTest : BrowserTestBase
                 targetProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server");
             }
 
-            await targetProject.RunDotNetPublishAsync(noRestore: false);
+            var publishResult = await targetProject.RunDotNetPublishAsync(noRestore: false);
+            Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", targetProject, publishResult));
 
             // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
             // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
             // later, while the opposite is not true.
 
-            await targetProject.RunDotNetBuildAsync();
+            var buildResult = await targetProject.RunDotNetBuildAsync();
+            Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", targetProject, buildResult));
         }
 
         return project;
diff --git a/src/ProjectTemplates/test/Templates.Blazor.Tests/BlazorWasmTemplateTest.cs b/src/ProjectTemplates/test/Templates.Blazor.Tests/BlazorWasmTemplateTest.cs
index ff0073cff2..a19b659670 100644
--- a/src/ProjectTemplates/test/Templates.Blazor.Tests/BlazorWasmTemplateTest.cs
+++ b/src/ProjectTemplates/test/Templates.Blazor.Tests/BlazorWasmTemplateTest.cs
@@ -248,20 +248,24 @@ public class BlazorWasmTemplateTest : BlazorTemplateTest
         var appSettingsPath = Path.Combine(serverProject.TemplateOutputDir, "appsettings.json");
         File.WriteAllText(appSettingsPath, replacedSection);
 
-        await serverProject.RunDotNetPublishAsync();
+        var publishResult = await serverProject.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", serverProject, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await serverProject.RunDotNetBuildAsync();
+        var buildResult = await serverProject.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", serverProject, buildResult));
 
-        await serverProject.RunDotNetEfCreateMigrationAsync("blazorwasm");
+        var migrationsResult = await serverProject.RunDotNetEfCreateMigrationAsync("blazorwasm");
+        Assert.True(0 == migrationsResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", serverProject, migrationsResult));
         serverProject.AssertEmptyMigration("blazorwasm");
 
         if (useLocalDb)
         {
-            await serverProject.RunDotNetEfUpdateDatabaseAsync();
+            var dbUpdateResult = await serverProject.RunDotNetEfUpdateDatabaseAsync();
+            Assert.True(0 == dbUpdateResult.ExitCode, ErrorMessages.GetFailedProcessMessage("update database", serverProject, dbUpdateResult));
         }
 
         return project;
diff --git a/src/ProjectTemplates/test/Templates.Blazor.WebAssembly.Auth.Tests/BlazorWasmTemplateAuthTest.cs b/src/ProjectTemplates/test/Templates.Blazor.WebAssembly.Auth.Tests/BlazorWasmTemplateAuthTest.cs
index 818b7b38fd..87754aab90 100644
--- a/src/ProjectTemplates/test/Templates.Blazor.WebAssembly.Auth.Tests/BlazorWasmTemplateAuthTest.cs
+++ b/src/ProjectTemplates/test/Templates.Blazor.WebAssembly.Auth.Tests/BlazorWasmTemplateAuthTest.cs
@@ -95,15 +95,18 @@ public class BlazorWasmTemplateAuthTest : BlazorTemplateTest
         var appSettingsPath = Path.Combine(serverProject.TemplateOutputDir, "appsettings.json");
         File.WriteAllText(appSettingsPath, replacedSection);
 
-        await serverProject.RunDotNetPublishAsync();
+        var publishResult = await serverProject.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", serverProject, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await serverProject.RunDotNetBuildAsync();
+        var buildResult = await serverProject.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", serverProject, buildResult));
 
-        await serverProject.RunDotNetEfCreateMigrationAsync("blazorwasm");
+        var migrationsResult = await serverProject.RunDotNetEfCreateMigrationAsync("blazorwasm");
+        Assert.True(0 == migrationsResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", serverProject, migrationsResult));
         serverProject.AssertEmptyMigration("blazorwasm");
 
         return project;
diff --git a/src/ProjectTemplates/test/Templates.Mvc.Tests/MvcTemplateTest.cs b/src/ProjectTemplates/test/Templates.Mvc.Tests/MvcTemplateTest.cs
index ef9a2e23aa..5db90382f6 100644
--- a/src/ProjectTemplates/test/Templates.Mvc.Tests/MvcTemplateTest.cs
+++ b/src/ProjectTemplates/test/Templates.Mvc.Tests/MvcTemplateTest.cs
@@ -55,7 +55,8 @@ public class MvcTemplateTest : LoggedTest
     {
         var project = await ProjectFactory.CreateProject(Output);
 
-        await project.RunDotNetNewAsync("mvc", language: languageOverride, args: args);
+        var createResult = await project.RunDotNetNewAsync("mvc", language: languageOverride, args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         var noHttps = args?.Contains(ArgConstants.NoHttps) ?? false;
         var expectedLaunchProfileNames = noHttps
@@ -77,13 +78,15 @@ public class MvcTemplateTest : LoggedTest
             return;
         }
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
         IEnumerable<string> menuLinks = new List<string> {
                 PageUrls.HomeUrl,
@@ -154,7 +157,8 @@ public class MvcTemplateTest : LoggedTest
             : noHttps
                 ? new[] { ArgConstants.NoHttps }
                 : null;
-        await project.RunDotNetNewAsync("mvc", auth: "Individual", useLocalDB: useLocalDB, args: args);
+        var createResult = await project.RunDotNetNewAsync("mvc", auth: "Individual", useLocalDB: useLocalDB, args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         var expectedLaunchProfileNames = noHttps
             ? new[] { "http", "IIS Express" }
@@ -167,15 +171,18 @@ public class MvcTemplateTest : LoggedTest
             Assert.Contains(".db", projectFileContents);
         }
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
-        await project.RunDotNetEfCreateMigrationAsync("mvc");
+        var migrationsResult = await project.RunDotNetEfCreateMigrationAsync("mvc");
+        Assert.True(0 == migrationsResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", project, migrationsResult));
         project.AssertEmptyMigration("mvc");
 
         // Note: if any links are updated here, RazorPagesTemplateTest.cs should be updated as well
@@ -277,9 +284,11 @@ public class MvcTemplateTest : LoggedTest
         var project = await ProjectFactory.CreateProject(Output);
         project.RuntimeIdentifier = runtimeIdentifer;
 
-        await project.RunDotNetNewAsync("mvc");
+        var createResult = await project.RunDotNetNewAsync("mvc");
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
-        await project.RunDotNetPublishAsync(additionalArgs: $"/p:PublishSingleFile=true -r {runtimeIdentifer} --self-contained", noRestore: false);
+        var publishResult = await project.RunDotNetPublishAsync(additionalArgs: $"/p:PublishSingleFile=true -r {runtimeIdentifer} --self-contained", noRestore: false);
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         var menuLinks = new[]
         {
@@ -352,17 +361,20 @@ public class MvcTemplateTest : LoggedTest
     {
         var project = await ProjectFactory.CreateProject(Output);
 
-        await project.RunDotNetNewAsync("mvc", auth: auth, args: args);
+        var createResult = await project.RunDotNetNewAsync("mvc", auth: auth, args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         // Identity Web auth requires https and thus ignores the --no-https option if passed so there should never be an 'http' profile
         var expectedLaunchProfileNames = new[] { "https", "IIS Express" };
         await project.VerifyLaunchSettings(expectedLaunchProfileNames);
 
         // Verify building in debug works
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
         // Publish builds in "release" configuration. Running publish should ensure we can compile in release and that we can publish without issues.
-        await project.RunDotNetPublishAsync();
+        buildResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, buildResult));
 
         return project;
     }
diff --git a/src/ProjectTemplates/test/Templates.Mvc.Tests/RazorPagesTemplateTest.cs b/src/ProjectTemplates/test/Templates.Mvc.Tests/RazorPagesTemplateTest.cs
index 027260aee6..a780a5cc80 100644
--- a/src/ProjectTemplates/test/Templates.Mvc.Tests/RazorPagesTemplateTest.cs
+++ b/src/ProjectTemplates/test/Templates.Mvc.Tests/RazorPagesTemplateTest.cs
@@ -51,7 +51,8 @@ public class RazorPagesTemplateTest : LoggedTest
             : noHttps
                 ? new[] { ArgConstants.NoHttps }
                 : null;
-        await project.RunDotNetNewAsync("razor", args: args);
+        var createResult = await project.RunDotNetNewAsync("razor", args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("razor", project, createResult));
 
         var expectedLaunchProfileNames = noHttps
             ? new[] { "http", "IIS Express" }
@@ -65,13 +66,15 @@ public class RazorPagesTemplateTest : LoggedTest
         Assert.DoesNotContain("Microsoft.EntityFrameworkCore.Tools.DotNet", projectFileContents);
         Assert.DoesNotContain("Microsoft.Extensions.SecretManager.Tools", projectFileContents);
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, createResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, createResult));
 
         var pages = new List<Page>
             {
@@ -144,7 +147,8 @@ public class RazorPagesTemplateTest : LoggedTest
             : noHttps
                 ? new[] { ArgConstants.NoHttps }
                 : null;
-        await project.RunDotNetNewAsync("razor", auth: "Individual", useLocalDB: useLocalDB, args: args);
+        var createResult = await project.RunDotNetNewAsync("razor", auth: "Individual", useLocalDB: useLocalDB, args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         // Individual auth supports no https OK
         var expectedLaunchProfileNames = noHttps
@@ -158,15 +162,18 @@ public class RazorPagesTemplateTest : LoggedTest
             Assert.Contains(".db", projectFileContents);
         }
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
-        await project.RunDotNetEfCreateMigrationAsync("razorpages");
+        var migrationsResult = await project.RunDotNetEfCreateMigrationAsync("razorpages");
+        Assert.True(0 == migrationsResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", project, migrationsResult));
         project.AssertEmptyMigration("razorpages");
 
         // Note: if any links are updated here, MvcTemplateTest.cs should be updated as well
@@ -290,17 +297,20 @@ public class RazorPagesTemplateTest : LoggedTest
     {
         var project = await ProjectFactory.CreateProject(Output);
 
-        await project.RunDotNetNewAsync("razor", auth: auth, args: args);
+        var createResult = await project.RunDotNetNewAsync("razor", auth: auth, args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         // Identity Web auth requires https and thus ignores the --no-https option if passed so there should never be an 'http' profile
         var expectedLaunchProfileNames = new[] { "https", "IIS Express" };
         await project.VerifyLaunchSettings(expectedLaunchProfileNames);
 
         // Verify building in debug works
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
         // Publish builds in "release" configuration. Running publish should ensure we can compile in release and that we can publish without issues.
-        await project.RunDotNetPublishAsync();
+        buildResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, buildResult));
 
         return project;
     }
diff --git a/src/ProjectTemplates/test/Templates.Mvc.Tests/WebApiTemplateTest.cs b/src/ProjectTemplates/test/Templates.Mvc.Tests/WebApiTemplateTest.cs
index 3e41e741fb..b580a812c9 100644
--- a/src/ProjectTemplates/test/Templates.Mvc.Tests/WebApiTemplateTest.cs
+++ b/src/ProjectTemplates/test/Templates.Mvc.Tests/WebApiTemplateTest.cs
@@ -165,9 +165,11 @@ public class WebApiTemplateTest : LoggedTest
             : useMinimalApis
                 ? new[] { ArgConstants.UseMinimalApis, ArgConstants.NoOpenApi }
                 : new[] { ArgConstants.NoOpenApi };
-        await project.RunDotNetNewAsync("webapi", args: args);
+        var createResult = await project.RunDotNetNewAsync("webapi", args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
         using var aspNetProcess = project.StartBuiltProjectAsync();
         Assert.False(
@@ -194,7 +196,8 @@ public class WebApiTemplateTest : LoggedTest
             : useMinimalApis
                 ? new[] { ArgConstants.UseMinimalApis, ArgConstants.NoOpenApi, ArgConstants.NoHttps }
                 : new[] { ArgConstants.NoOpenApi, ArgConstants.NoHttps };
-        await project.RunDotNetNewAsync("webapi", args: args);
+        var createResult = await project.RunDotNetNewAsync("webapi", args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         var noHttps = args.Contains(ArgConstants.NoHttps);
         var expectedLaunchProfileNames = noHttps
@@ -202,7 +205,8 @@ public class WebApiTemplateTest : LoggedTest
             : new[] { "http", "https", "IIS Express" };
         await project.VerifyLaunchSettings(expectedLaunchProfileNames);
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
         using var aspNetProcess = project.StartBuiltProjectAsync();
         Assert.False(
@@ -216,7 +220,8 @@ public class WebApiTemplateTest : LoggedTest
     {
         var project = await FactoryFixture.CreateProject(Output);
 
-        await project.RunDotNetNewAsync("webapi", language: languageOverride, auth: auth, args: args);
+        var createResult = await project.RunDotNetNewAsync("webapi", language: languageOverride, auth: auth, args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         // External auth mechanisms require https to work and thus don't honor the --no-https flag
         var requiresHttps = string.Equals(auth, "IndividualB2C", StringComparison.OrdinalIgnoreCase)
@@ -235,13 +240,15 @@ public class WebApiTemplateTest : LoggedTest
             return project;
         }
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
         return project;
     }
diff --git a/src/ProjectTemplates/test/Templates.Tests/BaselineTest.cs b/src/ProjectTemplates/test/Templates.Tests/BaselineTest.cs
index 335c1e6041..22993c25be 100644
--- a/src/ProjectTemplates/test/Templates.Tests/BaselineTest.cs
+++ b/src/ProjectTemplates/test/Templates.Tests/BaselineTest.cs
@@ -73,7 +73,8 @@ public class BaselineTest : LoggedTest
     public async Task Template_Produces_The_Right_Set_Of_FilesAsync(string arguments, string[] expectedFiles)
     {
         Project = await ProjectFactory.CreateProject(Output);
-        await Project.RunDotNetNewRawAsync(arguments);
+        var createResult = await Project.RunDotNetNewRawAsync(arguments);
+        Assert.True(createResult.ExitCode == 0, createResult.GetFormattedOutput());
 
         foreach (var file in expectedFiles)
         {
diff --git a/src/ProjectTemplates/test/Templates.Tests/EmptyWebTemplateTest.cs b/src/ProjectTemplates/test/Templates.Tests/EmptyWebTemplateTest.cs
index 9202743507..c99e3b836a 100644
--- a/src/ProjectTemplates/test/Templates.Tests/EmptyWebTemplateTest.cs
+++ b/src/ProjectTemplates/test/Templates.Tests/EmptyWebTemplateTest.cs
@@ -75,7 +75,8 @@ public class EmptyWebTemplateTest : LoggedTest
     {
         var project = await ProjectFactory.CreateProject(Output);
 
-        await project.RunDotNetNewAsync("web", args: args, language: languageOverride);
+        var createResult = await project.RunDotNetNewAsync("web", args: args, language: languageOverride);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         var noHttps = args?.Contains(ArgConstants.NoHttps) ?? false;
         var expectedLaunchProfileNames = noHttps
@@ -89,13 +90,15 @@ public class EmptyWebTemplateTest : LoggedTest
             return;
         }
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
         using (var aspNetProcess = project.StartBuiltProjectAsync())
         {
diff --git a/src/ProjectTemplates/test/Templates.Tests/GrpcTemplateTest.cs b/src/ProjectTemplates/test/Templates.Tests/GrpcTemplateTest.cs
index ae4f9cc297..81d3625162 100644
--- a/src/ProjectTemplates/test/Templates.Tests/GrpcTemplateTest.cs
+++ b/src/ProjectTemplates/test/Templates.Tests/GrpcTemplateTest.cs
@@ -45,14 +45,17 @@ public class GrpcTemplateTest : LoggedTest
         var project = await ProjectFactory.CreateProject(Output);
 
         var args = useProgramMain ? new[] { ArgConstants.UseProgramMain } : null;
-        await project.RunDotNetNewAsync("grpc", args: args);
+        var createResult = await project.RunDotNetNewAsync("grpc", args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         var expectedLaunchProfileNames = new[] { "http", "https" };
         await project.VerifyLaunchSettings(expectedLaunchProfileNames);
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
         var isOsx = RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
         var isWindowsOld = RuntimeInformation.IsOSPlatform(OSPlatform.Windows) && Environment.OSVersion.Version < new Version(6, 2);
diff --git a/src/ProjectTemplates/test/Templates.Tests/IdentityUIPackageTest.cs b/src/ProjectTemplates/test/Templates.Tests/IdentityUIPackageTest.cs
index 35c094758b..74ce8178c4 100644
--- a/src/ProjectTemplates/test/Templates.Tests/IdentityUIPackageTest.cs
+++ b/src/ProjectTemplates/test/Templates.Tests/IdentityUIPackageTest.cs
@@ -105,20 +105,24 @@ public class IdentityUIPackageTest : LoggedTest
         var project = await ProjectFactory.CreateProject(Output);
         var useLocalDB = false;
 
-        await project.RunDotNetNewAsync("razor", auth: "Individual", useLocalDB: useLocalDB, environmentVariables: packageOptions);
+        var createResult = await project.RunDotNetNewAsync("razor", auth: "Individual", useLocalDB: useLocalDB, environmentVariables: packageOptions);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
         var projectFileContents = ReadFile(project.TemplateOutputDir, $"{project.ProjectName}.csproj");
         Assert.Contains(".db", projectFileContents);
 
-        await project.RunDotNetPublishAsync(packageOptions: packageOptions);
+        var publishResult = await project.RunDotNetPublishAsync(packageOptions: packageOptions);
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync(packageOptions: packageOptions);
+        var buildResult = await project.RunDotNetBuildAsync(packageOptions: packageOptions);
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
-        await project.RunDotNetEfCreateMigrationAsync("razorpages");
+        var migrationsResult = await project.RunDotNetEfCreateMigrationAsync("razorpages");
+        Assert.True(0 == migrationsResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", project, migrationsResult));
         project.AssertEmptyMigration("razorpages");
 
         var versionValidator = "Bootstrap v5.1.0";
diff --git a/src/ProjectTemplates/test/Templates.Tests/ItemTemplateTests/BlazorServerTests.cs b/src/ProjectTemplates/test/Templates.Tests/ItemTemplateTests/BlazorServerTests.cs
index 643efd9a98..29c3a3e2cd 100644
--- a/src/ProjectTemplates/test/Templates.Tests/ItemTemplateTests/BlazorServerTests.cs
+++ b/src/ProjectTemplates/test/Templates.Tests/ItemTemplateTests/BlazorServerTests.cs
@@ -27,7 +27,8 @@ public class BlazorServerTest
     {
         Project = await ProjectFactory.CreateProject(Output);
 
-        await Project.RunDotNetNewAsync("razorcomponent --name Different");
+        var createResult = await Project.RunDotNetNewAsync("razorcomponent --name Different");
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create", Project, createResult));
 
         Project.AssertFileExists("Different.razor", shouldExist: true);
         Assert.Contains("<h3>Different</h3>", Project.ReadFile("Different.razor"));
diff --git a/src/ProjectTemplates/test/Templates.Tests/RazorClassLibraryTemplateTest.cs b/src/ProjectTemplates/test/Templates.Tests/RazorClassLibraryTemplateTest.cs
index 562d313c85..7675499fd0 100644
--- a/src/ProjectTemplates/test/Templates.Tests/RazorClassLibraryTemplateTest.cs
+++ b/src/ProjectTemplates/test/Templates.Tests/RazorClassLibraryTemplateTest.cs
@@ -35,15 +35,18 @@ public class RazorClassLibraryTemplateTest : LoggedTest
     {
         var project = await ProjectFactory.CreateProject(Output);
 
-        await project.RunDotNetNewAsync("razorclasslib", args: new[] { "--support-pages-and-views", "true" });
+        var createResult = await project.RunDotNetNewAsync("razorclasslib", args: new[] { "--support-pages-and-views", "true" });
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
     }
 
     [ConditionalFact]
@@ -52,14 +55,17 @@ public class RazorClassLibraryTemplateTest : LoggedTest
     {
         var project = await ProjectFactory.CreateProject(Output);
 
-        await project.RunDotNetNewAsync("razorclasslib");
+        var createResult = await project.RunDotNetNewAsync("razorclasslib");
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
     }
 }
diff --git a/src/ProjectTemplates/test/Templates.Tests/SpaTemplatesTest.cs b/src/ProjectTemplates/test/Templates.Tests/SpaTemplatesTest.cs
index 72e8107938..f067923b03 100644
--- a/src/ProjectTemplates/test/Templates.Tests/SpaTemplatesTest.cs
+++ b/src/ProjectTemplates/test/Templates.Tests/SpaTemplatesTest.cs
@@ -43,14 +43,17 @@ public class SpaTemplatesTest : LoggedTest
     {
         var project = await ProjectFactory.CreateProject(Output);
         var args = new[] { "--NoSpaFrontEnd", "true" };
-        await project.RunDotNetNewAsync(template, auth: auth, args: args);
+        var createResult = await project.RunDotNetNewAsync(template, auth: auth, args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage(template, project, createResult));
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
     }
 }
diff --git a/src/ProjectTemplates/test/Templates.Tests/WorkerTemplateTest.cs b/src/ProjectTemplates/test/Templates.Tests/WorkerTemplateTest.cs
index 4c1ad90756..53a4847912 100644
--- a/src/ProjectTemplates/test/Templates.Tests/WorkerTemplateTest.cs
+++ b/src/ProjectTemplates/test/Templates.Tests/WorkerTemplateTest.cs
@@ -38,15 +38,18 @@ public class WorkerTemplateTest : LoggedTest
     {
         var project = await ProjectFactory.CreateProject(Output);
 
-        await project.RunDotNetNewAsync("worker", language: language, args: args);
+        var createResult = await project.RunDotNetNewAsync("worker", language: language, args: args);
+        Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
 
-        await project.RunDotNetPublishAsync();
+        var publishResult = await project.RunDotNetPublishAsync();
+        Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult));
 
         // Run dotnet build after publish. The reason is that one uses Config = Debug and the other uses Config = Release
         // The output from publish will go into bin/Release/netcoreappX.Y/publish and won't be affected by calling build
         // later, while the opposite is not true.
 
-        await project.RunDotNetBuildAsync();
+        var buildResult = await project.RunDotNetBuildAsync();
+        Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult));
 
         using (var aspNetProcess = project.StartBuiltProjectAsync(hasListeningUri: false))
         {