Run blazor create/build/publish as part of template tests

src/ProjectTemplates/BlazorTemplates.Tests/BlazorTemplateTest.cs

@@ -112,13 +112,6 @@ protected async Task<Project> CreateBuildPublishAsync(string projectName, string
 
                 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.
-
-                var buildResult = await targetProject.RunDotNetBuildAsync();
-                Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", targetProject, buildResult));
             }
 
             return project;

src/ProjectTemplates/Shared/Project.cs

@@ -443,7 +443,7 @@ private void CaptureBinLogOnFailure(ProcessEx result)
                 var sourceFile = Path.Combine(TemplateOutputDir, "msbuild.binlog");
                 Assert.True(File.Exists(sourceFile), $"Log for '{ProjectName}' not found in '{sourceFile}'.");
                 var destination = Path.Combine(ArtifactsLogDir, ProjectName + ".binlog");
-                File.Move(sourceFile, destination);
+                File.Move(sourceFile, destination, overwrite: true); // binlog will exist on retries
             }
         }
 

src/ProjectTemplates/test/BlazorServerTemplateTest.cs

@@ -0,0 +1,46 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Testing;
+using Templates.Test.Helpers;
+using Xunit;
+using Xunit.Abstractions;
+using Xunit.Sdk;
+
+namespace Templates.Test
+{
+    public class BlazorServerTemplateTest : BlazorTemplateTest
+    {
+        public BlazorServerTemplateTest(ProjectFactoryFixture projectFactory)
+            : base(projectFactory)
+        {
+        }
+
+        public override string ProjectType { get; } = "blazorserver";
+
+        [Fact]
+        public Task BlazorServerTemplateWorks_NoAuth() => CreateBuildPublishAsync("blazorservernoauth");
+
+        [Theory]
+        [InlineData(true)]
+        [InlineData(false)]
+        [SkipOnHelix("https://github.com/dotnet/aspnetcore/issues/30825", Queues = "All.OSX")]
+        public Task BlazorServerTemplateWorks_IndividualAuth(bool useLocalDB) => CreateBuildPublishAsync("blazorserverindividual" + (useLocalDB ? "uld" : ""));
+
+        [Theory]
+        [InlineData("IndividualB2C", null)]
+        [InlineData("IndividualB2C", new string[] { "--called-api-url \"https://graph.microsoft.com\"", "--called-api-scopes user.readwrite" })]
+        [InlineData("SingleOrg", null)]
+        [InlineData("SingleOrg", new string[] { "--called-api-url \"https://graph.microsoft.com\"", "--called-api-scopes user.readwrite" })]
+        [InlineData("SingleOrg", new string[] { "--calls-graph" })]
+        [QuarantinedTest("https://github.com/dotnet/aspnetcore/issues/30882")]
+        public Task BlazorServerTemplate_IdentityWeb_BuildAndPublish(string auth, string[] args)
+            => CreateBuildPublishAsync("blazorserveridweb" + Guid.NewGuid().ToString().Substring(0, 10).ToLowerInvariant(), auth, args);
+
+    }
+}

src/ProjectTemplates/test/BlazorTemplateTest.cs

@@ -0,0 +1,92 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using System.Diagnostics;
+using System.IO;
+using System.Reflection;
+using System.Runtime.InteropServices;
+using System.Threading.Tasks;
+using Microsoft.AspNetCore.Testing;
+using Microsoft.Extensions.Configuration;
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Logging.Testing;
+using Templates.Test.Helpers;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Templates.Test
+{
+    public abstract class BlazorTemplateTest : LoggedTest
+    {
+        public BlazorTemplateTest(ProjectFactoryFixture projectFactory)
+        {
+            ProjectFactory = projectFactory;
+        }
+
+        public ProjectFactoryFixture ProjectFactory { get; set; }
+
+        private ITestOutputHelper _output;
+        public ITestOutputHelper Output
+        {
+            get
+            {
+                if (_output == null)
+                {
+                    _output = new TestOutputLogger(Logger);
+                }
+                return _output;
+            }
+        }
+
+        public abstract string ProjectType { get; }
+
+        protected async Task<Project> CreateBuildPublishAsync(string projectName, string auth = null, string[] args = null, string targetFramework = null, bool serverProject = false, bool onlyCreate = false)
+        {
+            // Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278
+            Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true");
+
+            var project = await ProjectFactory.GetOrCreateProject(projectName, Output);
+            if (targetFramework != null)
+            {
+                project.TargetFramework = targetFramework;
+            }
+
+            var createResult = await project.RunDotNetNewAsync(ProjectType, auth: auth, args: args);
+            Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
+
+            if (!onlyCreate)
+            {
+                var targetProject = project;
+                if (serverProject)
+                {
+                    targetProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server");
+                }
+
+                var publishResult = await targetProject.RunDotNetPublishAsync(noRestore: false);
+                Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", targetProject, publishResult));
+            }
+
+            return project;
+        }
+
+        protected static Project GetSubProject(Project project, string projectDirectory, string projectName)
+        {
+            var subProjectDirectory = Path.Combine(project.TemplateOutputDir, projectDirectory);
+            if (!Directory.Exists(subProjectDirectory))
+            {
+                throw new DirectoryNotFoundException($"Directory {subProjectDirectory} was not found.");
+            }
+
+            var subProject = new Project
+            {
+                Output = project.Output,
+                DiagnosticsMessageSink = project.DiagnosticsMessageSink,
+                ProjectName = projectName,
+                TemplateOutputDir = subProjectDirectory,
+            };
+
+            return subProject;
+        }
+    }
+}