Test all links in templates

src/Middleware/NodeServices/src/Microsoft.AspNetCore.NodeServices.csproj

@@ -1,5 +1,4 @@
 <Project Sdk="Microsoft.NET.Sdk">
-
   <PropertyGroup>
     <Description>Invoke Node.js modules at runtime in ASP.NET Core applications.</Description>
     <TargetFramework>netcoreapp3.0</TargetFramework>

src/ProjectTemplates/Web.ProjectTemplates/RazorClassLibrary-CSharp.csproj.in

@@ -6,6 +6,7 @@
     <RazorLangVersion Condition="'$(SupportPagesAndViews)' != 'True'">3.0</RazorLangVersion>
     <AddRazorSupportForMvc Condition="'$(SupportPagesAndViews)' == 'True'">true</AddRazorSupportForMvc>
     <RootNamespace Condition="'$(name)' != '$(name{-VALUE-FORMS-}safe_namespace)'">Company.RazorClassLibrary1</RootNamespace>
+    <AddRazorSupportForMvc Condition="'$(SupportPagesAndViews)' == 'True'">true</AddRazorSupportForMvc>
   </PropertyGroup>
 
   <ItemGroup Condition="'$(SupportPagesAndViews)' == 'True'">

src/ProjectTemplates/test/EmptyWebTemplateTest.cs

@@ -22,12 +22,14 @@ public EmptyWebTemplateTest(ProjectFactoryFixture projectFactory, ITestOutputHel
 
         public ITestOutputHelper Output { get; }
 
-        [Fact]
-        public async Task EmptyWebTemplateAsync()
+        [Theory]
+        [InlineData(null)]
+        [InlineData("F#")]
+        public async Task EmptyWebTemplateAsync(string languageOverride)
         {
-            Project = await ProjectFactory.GetOrCreateProject("empty", Output);
+            Project = await ProjectFactory.GetOrCreateProject("empty" + (languageOverride == "F#" ? "fsharp" : "csharp"), Output);
 
-            var createResult = await Project.RunDotNetNewAsync("web");
+            var createResult = await Project.RunDotNetNewAsync("web", language: languageOverride);
             Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", Project, createResult));
 
             var publishResult = await Project.RunDotNetPublishAsync();
@@ -43,8 +45,8 @@ public async Task EmptyWebTemplateAsync()
             using (var aspNetProcess = Project.StartBuiltProjectAsync())
             {
                 Assert.False(
-                    aspNetProcess.Process.HasExited,
-                    ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", Project, aspNetProcess.Process));
+                   aspNetProcess.Process.HasExited,
+                   ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", Project, aspNetProcess.Process));
 
                 await aspNetProcess.AssertOk("/");
             }

src/ProjectTemplates/test/GrpcTemplateTest.cs

@@ -0,0 +1,71 @@
+// 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.Threading.Tasks;
+using Templates.Test.Helpers;
+using Xunit;
+using Xunit.Abstractions;
+
+namespace Templates.Test
+{
+    public class GrpcTemplateTest
+    {
+        public GrpcTemplateTest(ProjectFactoryFixture projectFactory, ITestOutputHelper output)
+        {
+            ProjectFactory = projectFactory;
+            Output = output;
+        }
+
+        public Project Project { get; set; }
+
+        public ProjectFactoryFixture ProjectFactory { get; }
+        public ITestOutputHelper Output { get; }
+
+        [Fact(Skip = "https://github.com/aspnet/AspNetCore/issues/7973")]
+        public async Task GrpcTemplate()
+        {
+            Project = await ProjectFactory.GetOrCreateProject("grpc", Output);
+
+            var createResult = await Project.RunDotNetNewAsync("grpc");
+            Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", Project, createResult));
+
+            var publishResult = await Project.RunDotNetPublishAsync();
+            Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", Project, publishResult));
+
+            var buildResult = await Project.RunDotNetBuildAsync();
+            Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", Project, buildResult));
+
+            using (var serverProcess = Project.StartBuiltServerAsync())
+            {
+                Assert.False(
+                    serverProcess.Process.HasExited,
+                    ErrorMessages.GetFailedProcessMessageOrEmpty("Run built server", Project, serverProcess.Process));
+
+                using (var clientProcess = Project.StartBuiltClientAsync(serverProcess))
+                {
+                    // Wait for the client to do its thing
+                    await Task.Delay(100);
+                    Assert.False(
+                        clientProcess.Process.HasExited,
+                        ErrorMessages.GetFailedProcessMessageOrEmpty("Run built client", Project, clientProcess.Process));
+                }
+            }
+
+            using (var aspNetProcess = Project.StartPublishedServerAsync())
+            {
+                Assert.False(
+                    aspNetProcess.Process.HasExited,
+                    ErrorMessages.GetFailedProcessMessageOrEmpty("Run published server", Project, aspNetProcess.Process));
+
+                using (var clientProcess = Project.StartPublishedClientAsync())
+                {
+                    // Wait for the client to do its thing
+                    await Task.Delay(100);
+                    Assert.False(
+                        clientProcess.Process.HasExited,
+                        ErrorMessages.GetFailedProcessMessageOrEmpty("Run built client", Project, clientProcess.Process));
+                }
+            }
+        }
+    }
+}

src/ProjectTemplates/test/Helpers/AspNetProcess.cs

@@ -8,6 +8,8 @@
 using System.Net;
 using System.Net.Http;
 using System.Threading.Tasks;
+using AngleSharp.Dom.Html;
+using AngleSharp.Parser.Html;
 using Microsoft.AspNetCore.Certificates.Generation;
 using Microsoft.Extensions.CommandLineUtils;
 using OpenQA.Selenium;
@@ -21,17 +23,19 @@ namespace Templates.Test.Helpers
     public class AspNetProcess : IDisposable
     {
         private const string ListeningMessagePrefix = "Now listening on: ";
-        private readonly Uri _listeningUri;
         private readonly HttpClient _httpClient;
         private readonly ITestOutputHelper _output;
 
+        internal readonly Uri ListeningUri;
         internal ProcessEx Process { get; }
 
         public AspNetProcess(
             ITestOutputHelper output,
             string workingDirectory,
             string dllPath,
-            IDictionary<string, string> environmentVariables)
+            IDictionary<string, string> environmentVariables,
+            bool published = true,
+            bool hasListeningUri = true)
         {
             _output = output;
             _httpClient = new HttpClient(new HttpClientHandler()
@@ -48,18 +52,20 @@ public AspNetProcess(
             var now = DateTimeOffset.Now;
             new CertificateManager().EnsureAspNetCoreHttpsDevelopmentCertificate(now, now.AddYears(1));
 
-
             output.WriteLine("Running ASP.NET application...");
 
-            Process = ProcessEx.Run(output, workingDirectory, DotNetMuxer.MuxerPathOrDefault(), $"exec {dllPath}", envVars: environmentVariables);
-            _listeningUri = GetListeningUri(output);
+            var arguments = published ? $"exec {dllPath}" : "run";
+            Process = ProcessEx.Run(output, workingDirectory, DotNetMuxer.MuxerPathOrDefault(), arguments, envVars: environmentVariables);
+            if(hasListeningUri)
+            {
+                ListeningUri = GetListeningUri(output);
+            }
         }
 
-
         public void VisitInBrowser(IWebDriver driver)
         {
-            _output.WriteLine($"Opening browser at {_listeningUri}...");
-            driver.Navigate().GoToUrl(_listeningUri);
+            _output.WriteLine($"Opening browser at {ListeningUri}...");
+            driver.Navigate().GoToUrl(ListeningUri);
 
             if (driver is EdgeDriver)
             {
@@ -75,7 +81,7 @@ public void VisitInBrowser(IWebDriver driver)
                     {
                         _output.WriteLine($"Clicking on link '{continueLink.Text}' to skip invalid certificate error page.");
                         continueLink.Click();
-                        driver.Navigate().GoToUrl(_listeningUri);
+                        driver.Navigate().GoToUrl(ListeningUri);
                     }
                     else
                     {
@@ -85,6 +91,58 @@ public void VisitInBrowser(IWebDriver driver)
             }
         }
 
+        public async Task AssertPagesOk(IEnumerable<Page> pages)
+        {
+            foreach (var page in pages)
+            {
+                await AssertOk(page.Url);
+                await ContainsLinks(page);
+            }
+        }
+
+        public async Task ContainsLinks(Page page)
+        {
+            var request = new HttpRequestMessage(
+                HttpMethod.Get,
+                new Uri(ListeningUri, page.Url));
+
+            var response = await _httpClient.SendAsync(request);
+
+            Assert.Equal(HttpStatusCode.OK, response.StatusCode);
+            var parser = new HtmlParser();
+            var html = await parser.ParseAsync(await response.Content.ReadAsStreamAsync());
+
+            foreach (IHtmlLinkElement styleSheet in html.GetElementsByTagName("link"))
+            {
+                Assert.Equal("stylesheet", styleSheet.Relation);
+                await AssertOk(styleSheet.Href.Replace("about://", string.Empty));
+            }
+            foreach (var script in html.Scripts)
+            {
+                if (!string.IsNullOrEmpty(script.Source))
+                {
+                    await AssertOk(script.Source);
+                }
+            }
+
+            Assert.True(html.Links.Length == page.Links.Count(), $"Expected {page.Url} to have {page.Links.Count()} links but it had {html.Links.Length}");
+            foreach ((var link, var expectedLink) in html.Links.Zip(page.Links, Tuple.Create))
+            {
+                IHtmlAnchorElement anchor = (IHtmlAnchorElement)link;
+                if (string.Equals(anchor.Protocol, "about:"))
+                {
+                    Assert.True(anchor.PathName.EndsWith(expectedLink), $"Expected next link on {page.Url} to be {expectedLink} but it was {anchor.PathName}.");
+                    await AssertOk(anchor.PathName);
+                }
+                else
+                {
+                    Assert.True(string.Equals(anchor.Href, expectedLink), $"Expected next link to be {expectedLink} but it was {anchor.Href}.");
+                    var result = await _httpClient.GetAsync(anchor.Href);
+                    Assert.True(IsSuccessStatusCode(result), $"{anchor.Href} is a broken link!");
+                }
+            }
+        }
+
         private Uri GetListeningUri(ITestOutputHelper output)
         {
             // Wait until the app is accepting HTTP requests
@@ -113,6 +171,11 @@ private Uri GetListeningUri(ITestOutputHelper output)
             }
         }
 
+        private bool IsSuccessStatusCode(HttpResponseMessage response)
+        {
+            return response.IsSuccessStatusCode || response.StatusCode == HttpStatusCode.Redirect;
+        }
+
         public Task AssertOk(string requestUrl)
             => AssertStatusCode(requestUrl, HttpStatusCode.OK);
 
@@ -121,22 +184,22 @@ public Task AssertNotFound(string requestUrl)
 
         internal Task<HttpResponseMessage> SendRequest(string path)
         {
-            return _httpClient.GetAsync(new Uri(_listeningUri, path));
+            return _httpClient.GetAsync(new Uri(ListeningUri, path));
         }
 
         public async Task AssertStatusCode(string requestUrl, HttpStatusCode statusCode, string acceptContentType = null)
         {
             var request = new HttpRequestMessage(
                 HttpMethod.Get,
-                new Uri(_listeningUri, requestUrl));
+                new Uri(ListeningUri, requestUrl));
 
             if (!string.IsNullOrEmpty(acceptContentType))
             {
                 request.Headers.Add("Accept", acceptContentType);
             }
 
             var response = await _httpClient.SendAsync(request);
-            Assert.Equal(statusCode, response.StatusCode);
+            Assert.True(statusCode == response.StatusCode, $"Expected {requestUrl} to have status '{statusCode}' but it was '{response.StatusCode}'.");
         }
 
         public void Dispose()
@@ -153,7 +216,7 @@ public override string ToString()
             {
                 if (!Process.HasExited)
                 {
-                    result += $"(Listening on {_listeningUri.OriginalString}) PID: {Process.Id}";
+                    result += $"(Listening on {ListeningUri.OriginalString}) PID: {Process.Id}";
                 }
                 else
                 {
@@ -164,4 +227,10 @@ public override string ToString()
             return result;
         }
     }
+
+    public class Page
+    {
+        public string Url { get; set; }
+        public IEnumerable<string> Links { get; set; }
+    }
 }

src/ProjectTemplates/test/Helpers/PageUrls.cs

@@ -0,0 +1,17 @@
+// 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.
+
+namespace Templates.Test.Helpers
+{
+    public static class PageUrls
+    {
+        public const string HomeUrl = "/";
+        public const string PrivacyUrl = "/Privacy";
+        public const string PrivacyFullUrl = "/Home/Privacy";
+        public const string DocsUrl = "https://docs.microsoft.com/aspnet/core";
+        public const string LoginUrl = "/Identity/Account/Login";
+        public const string RegisterUrl = "/Identity/Account/Register";
+        public const string ForgotPassword = "/Identity/Account/ForgotPassword";
+        public const string ExternalArticle = "https://go.microsoft.com/fwlink/?LinkID=532715";
+    }
+}