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.StartBuiltProjectAsync()) { Assert.False( serverProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built service", Project, serverProcess.Process)); } using (var aspNetProcess = Project.StartPublishedProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published service", Project, aspNetProcess.Process)); } }
private async Task BlazorWasmHostedTemplate_IndividualAuth_Works(BrowserKind browserKind, bool useLocalDb) { var project = await ProjectFactory.GetOrCreateProject("blazorhostedindividual" + browserKind + (useLocalDb ? "uld" : ""), Output); var serverProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server"); await BuildAndRunTest(project.ProjectName, serverProject, browserKind, usesAuth : true); UpdatePublishedSettings(serverProject); if (BrowserManager.IsAvailable(browserKind)) { using var aspNetProcess = serverProject.StartPublishedProjectAsync(); Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", serverProject, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo); var page = await browser.NewPageAsync(); await aspNetProcess.VisitInBrowserAsync(page); await TestBasicNavigation(project.ProjectName, page, usesAuth : true); await page.CloseAsync(); } else { EnsureBrowserAvailable(browserKind); } }
public async Task Template_Produces_The_Right_Set_Of_FilesAsync(string arguments, string[] expectedFiles) { Project = await ProjectFactory.GetOrCreateProject("baseline" + SanitizeArgs(arguments), Output); var createResult = await Project.RunDotNetNewRawAsync(arguments); Assert.True(createResult.ExitCode == 0, createResult.GetFormattedOutput()); foreach (var file in expectedFiles) { AssertFileExists(Project.TemplateOutputDir, file, shouldExist: true); } var filesInFolder = Directory.EnumerateFiles(Project.TemplateOutputDir, "*", SearchOption.AllDirectories); foreach (var file in filesInFolder) { var relativePath = file.Replace(Project.TemplateOutputDir, "").Replace("\\", "/").Trim('/'); if (relativePath.EndsWith(".csproj", StringComparison.Ordinal) || relativePath.EndsWith(".fsproj", StringComparison.Ordinal) || relativePath.EndsWith(".props", StringComparison.Ordinal) || relativePath.EndsWith(".targets", StringComparison.Ordinal) || relativePath.StartsWith("bin/", StringComparison.Ordinal) || relativePath.StartsWith("obj/", StringComparison.Ordinal)) { continue; } Assert.Contains(relativePath, expectedFiles); } }
public async Task WorkerTemplateAsync() { Project = await ProjectFactory.GetOrCreateProject("worker", Output); var createResult = await Project.RunDotNetNewAsync("worker"); 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)); // 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 Project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", Project, buildResult)); using (var aspNetProcess = Project.StartBuiltProjectAsync(hasListeningUri: false)) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", Project, aspNetProcess.Process)); } using (var aspNetProcess = Project.StartPublishedProjectAsync(hasListeningUri: false)) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", Project, aspNetProcess.Process)); } }
public async Task BlazorWasmHostedTemplate_Works(BrowserKind browserKind) { var project = await ProjectFactory.GetOrCreateProject("blazorhosted" + browserKind, Output); var serverProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server"); await BuildAndRunTest(project.ProjectName, serverProject, browserKind); using var aspNetProcess = serverProject.StartPublishedProjectAsync(); Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", serverProject, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); await AssertCompressionFormat(aspNetProcess, "br"); if (BrowserManager.IsAvailable(browserKind)) { await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo); var page = await browser.NewPageAsync(); await aspNetProcess.VisitInBrowserAsync(page); await TestBasicNavigation(project.ProjectName, page); } else { EnsureBrowserAvailable(browserKind); } }
public async Task IdentityUIPackage_WorksWithDifferentOptions() { var packageOptions = new Dictionary <string, string>(); var project = await ProjectFactory.GetOrCreateProject("identityuipackage" + string.Concat(packageOptions.Values), Output); var useLocalDB = false; 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); 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. var buildResult = await project.RunDotNetBuildAsync(packageOptions : packageOptions); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult)); var migrationsResult = await project.RunDotNetEfCreateMigrationAsync("razorpages"); Assert.True(0 == migrationsResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", project, migrationsResult)); project.AssertEmptyMigration("razorpages"); var versionValidator = "Bootstrap v4.3.1"; using (var aspNetProcess = project.StartBuiltProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", project, aspNetProcess.Process)); var response = await aspNetProcess.SendRequest("/Identity/lib/bootstrap/dist/css/bootstrap.css"); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Contains(versionValidator, await response.Content.ReadAsStringAsync()); await ValidatePublishedFiles(aspNetProcess, Bootstrap4ContentFiles); } using (var aspNetProcess = project.StartPublishedProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", project, aspNetProcess.Process)); var response = await aspNetProcess.SendRequest("/Identity/lib/bootstrap/dist/css/bootstrap.css"); Assert.Equal(HttpStatusCode.OK, response.StatusCode); Assert.Contains(versionValidator, await response.Content.ReadAsStringAsync()); await ValidatePublishedFiles(aspNetProcess, Bootstrap4ContentFiles); } }
public async Task RazorPagesTemplate_RazorRuntimeCompilation_BuildsAndPublishes() { Project = await ProjectFactory.GetOrCreateProject("razorpages_rc", Output); var createResult = await Project.RunDotNetNewAsync("razor", args : new[] { "--razor-runtime-compilation" }); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", Project, createResult)); // Verify building in debug works 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. buildResult = await Project.RunDotNetPublishAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", Project, buildResult)); Assert.False(Directory.Exists(Path.Combine(Project.TemplatePublishDir, "refs")), "The refs directory should not be published."); // Verify ref assemblies isn't published var refsDirectory = Path.Combine(Project.TemplatePublishDir, "refs"); Assert.False(Directory.Exists(refsDirectory), $"{refsDirectory} should not be in the publish output."); }
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); }
public async Task BlazorServerTemplateWorks_NoAuth() { Project = await ProjectFactory.GetOrCreateProject("blazorservernoauth", Output); var createResult = await Project.RunDotNetNewAsync("blazorserver"); 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)); // 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 Project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", Project, buildResult)); using (var aspNetProcess = Project.StartBuiltProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", Project, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); if (BrowserFixture.IsHostAutomationSupported()) { aspNetProcess.VisitInBrowser(Browser); TestBasicNavigation(); } else { BrowserFixture.EnforceSupportedConfigurations(); } } using (var aspNetProcess = Project.StartPublishedProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", Project, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); if (BrowserFixture.IsHostAutomationSupported()) { aspNetProcess.VisitInBrowser(Browser); TestBasicNavigation(); } else { BrowserFixture.EnforceSupportedConfigurations(); } } }
public async Task BlazorServerTemplateWorks_IndividualAuth(bool useLocalDB) { // Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278 Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true"); Project = await ProjectFactory.GetOrCreateProject("blazorserverindividual" + (useLocalDB ? "uld" : ""), Output); var createResult = await Project.RunDotNetNewAsync("blazorserver", auth : "Individual", useLocalDB : useLocalDB); 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)); // 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 Project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", Project, buildResult)); using (var aspNetProcess = Project.StartBuiltProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", Project, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); if (BrowserFixture.IsHostAutomationSupported()) { aspNetProcess.VisitInBrowser(Browser); TestBasicNavigation(); } else { BrowserFixture.EnforceSupportedConfigurations(); } } using (var aspNetProcess = Project.StartPublishedProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", Project, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); if (BrowserFixture.IsHostAutomationSupported()) { aspNetProcess.VisitInBrowser(Browser); TestBasicNavigation(); } } }
public async Task MvcTemplate_NoAuthImplAsync(string languageOverride) { Project = await ProjectFactory.GetOrCreateProject("mvcnoauth" + (languageOverride == "F#" ? "fsharp" : "csharp"), Output); var createResult = await Project.RunDotNetNewAsync("mvc", language : languageOverride); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", Project, createResult)); AssertDirectoryExists(Project.TemplateOutputDir, "Areas", false); AssertDirectoryExists(Project.TemplateOutputDir, "Extensions", false); AssertFileExists(Project.TemplateOutputDir, "urlRewrite.config", false); AssertFileExists(Project.TemplateOutputDir, "Controllers/AccountController.cs", false); var projectExtension = languageOverride == "F#" ? "fsproj" : "csproj"; var projectFileContents = ReadFile(Project.TemplateOutputDir, $"{Project.ProjectName}.{projectExtension}"); Assert.DoesNotContain(".db", projectFileContents); Assert.DoesNotContain("Microsoft.EntityFrameworkCore.Tools", projectFileContents); Assert.DoesNotContain("Microsoft.VisualStudio.Web.CodeGeneration.Design", projectFileContents); Assert.DoesNotContain("Microsoft.EntityFrameworkCore.Tools.DotNet", projectFileContents); Assert.DoesNotContain("Microsoft.Extensions.SecretManager.Tools", projectFileContents); 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/netcoreapp3.0/publish and won't be affected by calling build // later, while the opposite is not true. var buildResult = await Project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", Project, buildResult)); using (var aspNetProcess = Project.StartBuiltProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", Project, aspNetProcess.Process)); await aspNetProcess.AssertOk("/"); await aspNetProcess.AssertOk("/Home/Privacy"); } using (var aspNetProcess = Project.StartPublishedProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", Project, aspNetProcess.Process)); await aspNetProcess.AssertOk("/"); await aspNetProcess.AssertOk("/Home/Privacy"); } }
public async Task BlazorServerItemTemplate() { Project = await ProjectFactory.GetOrCreateProject("razorcomponentitem", Output); 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")); }
public async Task BlazorServerTemplateWorks_NoAuth(BrowserKind browserKind) { var project = await ProjectFactory.GetOrCreateProject("blazorservernoauth" + browserKind, Output); await using var browser = BrowserManager.IsAvailable(browserKind) ? await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo) : null; using (var aspNetProcess = project.StartBuiltProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", project, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); if (BrowserManager.IsAvailable(browserKind)) { var page = await browser.NewPageAsync(); await aspNetProcess.VisitInBrowserAsync(page); await TestBasicNavigation(project, page); await page.CloseAsync(); } else { EnsureBrowserAvailable(browserKind); } } using (var aspNetProcess = project.StartPublishedProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", project, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); if (BrowserManager.IsAvailable(browserKind)) { var page = await browser.NewPageAsync(); await aspNetProcess.VisitInBrowserAsync(page); await TestBasicNavigation(project, page); await page.CloseAsync(); } else { EnsureBrowserAvailable(browserKind); } } }
public async Task MvcTemplate_IndividualAuthImplAsync(bool useLocalDB) { Project = await ProjectFactory.GetOrCreateProject("mvcindividual" + (useLocalDB ? "uld" : ""), Output); var createResult = await Project.RunDotNetNewAsync("mvc", auth : "Individual", useLocalDB : useLocalDB); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", Project, createResult)); AssertDirectoryExists(Project.TemplateOutputDir, "Extensions", false); AssertFileExists(Project.TemplateOutputDir, "urlRewrite.config", false); AssertFileExists(Project.TemplateOutputDir, "Controllers/AccountController.cs", false); var projectFileContents = ReadFile(Project.TemplateOutputDir, $"{Project.ProjectName}.csproj"); if (!useLocalDB) { Assert.Contains(".db", projectFileContents); } 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/netcoreapp3.0/publish and won't be affected by calling build // later, while the opposite is not true. var buildResult = await Project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", Project, buildResult)); var migrationsResult = await Project.RunDotNetEfCreateMigrationAsync("mvc"); Assert.True(0 == migrationsResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", Project, migrationsResult)); Project.AssertEmptyMigration("mvc"); using (var aspNetProcess = Project.StartBuiltProjectAsync()) { await aspNetProcess.AssertOk("/"); await aspNetProcess.AssertOk("/Identity/Account/Login"); await aspNetProcess.AssertOk("/Home/Privacy"); } using (var aspNetProcess = Project.StartPublishedProjectAsync()) { await aspNetProcess.AssertOk("/"); await aspNetProcess.AssertOk("/Identity/Account/Login"); await aspNetProcess.AssertOk("/Home/Privacy"); } }
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.StartBuiltProjectAsync()) { // These templates are HTTPS + HTTP/2 only which is not supported on Mac due to missing ALPN support. // https://github.com/aspnet/AspNetCore/issues/11061 if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { Assert.True(serverProcess.Process.HasExited, "built"); Assert.Contains("System.NotSupportedException: HTTP/2 over TLS is not supported on OSX due to missing ALPN support.", ErrorMessages.GetFailedProcessMessageOrEmpty("Run built service", Project, serverProcess.Process)); } else { Assert.False( serverProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built service", Project, serverProcess.Process)); } } using (var aspNetProcess = Project.StartPublishedProjectAsync()) { // These templates are HTTPS + HTTP/2 only which is not supported on Mac due to missing ALPN support. // https://github.com/aspnet/AspNetCore/issues/11061 if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX)) { Assert.True(aspNetProcess.Process.HasExited, "published"); Assert.Contains("System.NotSupportedException: HTTP/2 over TLS is not supported on OSX due to missing ALPN support.", ErrorMessages.GetFailedProcessMessageOrEmpty("Run published service", Project, aspNetProcess.Process)); } else { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published service", Project, aspNetProcess.Process)); } } }
public async Task RazorPagesTemplate_NoAuthImplAsync() { Project = await ProjectFactory.GetOrCreateProject("razorpagesnoauth", Output); var createResult = await Project.RunDotNetNewAsync("razor"); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("razor", Project, createResult)); AssertFileExists(Project.TemplateOutputDir, "Pages/Shared/_LoginPartial.cshtml", false); var projectFileContents = ReadFile(Project.TemplateOutputDir, $"{Project.ProjectName}.csproj"); Assert.DoesNotContain(".db", projectFileContents); Assert.DoesNotContain("Microsoft.EntityFrameworkCore.Tools", projectFileContents); Assert.DoesNotContain("Microsoft.VisualStudio.Web.CodeGeneration.Design", projectFileContents); Assert.DoesNotContain("Microsoft.EntityFrameworkCore.Tools.DotNet", projectFileContents); Assert.DoesNotContain("Microsoft.Extensions.SecretManager.Tools", projectFileContents); 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/netcoreapp3.0/publish and won't be affected by calling build // later, while the opposite is not true. var buildResult = await Project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", Project, createResult)); using (var aspNetProcess = Project.StartBuiltProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", Project, aspNetProcess.Process)); await aspNetProcess.AssertOk("/"); await aspNetProcess.AssertOk("/Privacy"); } using (var aspNetProcess = Project.StartPublishedProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", Project, aspNetProcess.Process)); await aspNetProcess.AssertOk("/"); await aspNetProcess.AssertOk("/Privacy"); } }
public async Task BlazorWasmStandalonePwaTemplate_Works(BrowserKind browserKind) { // Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278 Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true"); var project = await ProjectFactory.GetOrCreateProject("blazorstandalonepwa", Output); var createResult = await project.RunDotNetNewAsync("blazorwasm", args : new[] { "--pwa" }); 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)); await BuildAndRunTest(project.ProjectName, project, browserKind); ValidatePublishedServiceWorker(project); if (Fixture.BrowserManager.IsAvailable(browserKind)) { var(serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project); await using var browser = await Fixture.BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo); Output.WriteLine($"Opening browser at {listeningUri}..."); var page = await NavigateToPage(browser, listeningUri); using (serveProcess) { await TestBasicNavigation(project.ProjectName, page); } // The PWA template supports offline use. By now, the browser should have cached everything it needs, // so we can continue working even without the server. await page.GoToAsync("about:blank"); await browser.SetOfflineAsync(true); await page.GoToAsync(listeningUri); await TestBasicNavigation(project.ProjectName, page, skipFetchData : true); await page.CloseAsync(); } else { EnsureBrowserAvailable(browserKind); } }
public async Task BlazorWasmHostedPwaTemplate_Works(BrowserKind browserKind) { var project = await ProjectFactory.GetOrCreateProject("blazorhostedpwa", Output); var serverProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server"); await BuildAndRunTest(project.ProjectName, serverProject, browserKind); ValidatePublishedServiceWorker(serverProject); string listeningUri = null; if (BrowserManager.IsAvailable(browserKind)) { await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo); IPage page = null; using (var aspNetProcess = serverProject.StartPublishedProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", serverProject, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); page = await browser.NewPageAsync(); await aspNetProcess.VisitInBrowserAsync(page); await TestBasicNavigation(project.ProjectName, page); // Note: we don't want to use aspNetProcess.ListeningUri because that isn't necessarily the HTTPS URI listeningUri = new Uri(page.Url).GetLeftPart(UriPartial.Authority); } // The PWA template supports offline use. By now, the browser should have cached everything it needs, // so we can continue working even without the server. // Since this is the hosted project, backend APIs won't work offline, so we need to skip "fetchdata" await page.GoToAsync("about:blank"); await browser.SetOfflineAsync(true); await page.GoToAsync(listeningUri); await TestBasicNavigation(project.ProjectName, page, skipFetchData : true); await page.CloseAsync(); } else { EnsureBrowserAvailable(browserKind); } }
public async Task BlazorWasmStandaloneTemplate_IndividualAuth_Works(BrowserKind browserKind) { // Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278 Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true"); var project = await ProjectFactory.GetOrCreateProject("blazorstandaloneindividual" + browserKind, Output); var createResult = await project.RunDotNetNewAsync("blazorwasm", args : new[] { "-au", "Individual", "--authority", "https://login.microsoftonline.com/common/v2.0/.well-known/openid-configuration", "--client-id", "sample-client-id" }); 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)); // 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 project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult)); // We don't want to test the auth flow as we don't have the required settings to talk to a third-party IdP // but we want to make sure that we are able to run the app without errors. // That will at least test that we are able to initialize and retrieve the configuration from the IdP // for that, we use the common microsoft tenant. await BuildAndRunTest(project.ProjectName, project, browserKind, usesAuth : false); var(serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project); using (serveProcess) { Output.WriteLine($"Opening browser at {listeningUri}..."); await using var browser = await Fixture.BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo); var page = await NavigateToPage(browser, listeningUri); await TestBasicNavigation(project.ProjectName, page); await page.CloseAsync(); } }
public async Task BlazorWasmHostedTemplate_Works(BrowserKind browserKind) { // Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278 Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true"); var project = await ProjectFactory.GetOrCreateProject("blazorhosted" + browserKind, Output); var createResult = await project.RunDotNetNewAsync("blazorwasm", args : new[] { "--hosted" }); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult)); var serverProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server"); var publishResult = await serverProject.RunDotNetPublishAsync(); Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", serverProject, publishResult)); var buildResult = await serverProject.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", serverProject, buildResult)); await BuildAndRunTest(project.ProjectName, serverProject, browserKind); using var aspNetProcess = serverProject.StartPublishedProjectAsync(); Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", serverProject, aspNetProcess.Process)); await aspNetProcess.AssertStatusCode("/", HttpStatusCode.OK, "text/html"); await AssertCompressionFormat(aspNetProcess, "br"); if (Fixture.BrowserManager.IsAvailable(browserKind)) { await using var browser = await Fixture.BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo); var page = await browser.NewPageAsync(); await aspNetProcess.VisitInBrowserAsync(page); await TestBasicNavigation(project.ProjectName, page); } else { EnsureBrowserAvailable(browserKind); } }
public async Task MvcTemplate_SingleFileExe() { // This test verifies publishing an MVC app as a single file exe works. We'll limit testing // this to a few operating systems to make our lives easier. var runtimeIdentifer = "win-x64"; var project = await ProjectFactory.GetOrCreateProject("mvcsinglefileexe", Output); project.RuntimeIdentifier = runtimeIdentifer; var createResult = await project.RunDotNetNewAsync("mvc"); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult)); var publishResult = await project.RunDotNetPublishAsync(additionalArgs : $"/p:PublishSingleFile=true -r {runtimeIdentifer}", noRestore : false); Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", project, publishResult)); var menuLinks = new[] { PageUrls.HomeUrl, PageUrls.HomeUrl, PageUrls.PrivacyFullUrl }; var footerLinks = new[] { PageUrls.PrivacyFullUrl }; var pages = new List <Page> { new Page { Url = PageUrls.HomeUrl, Links = menuLinks.Append(PageUrls.DocsUrl).Concat(footerLinks), }, new Page { Url = PageUrls.PrivacyFullUrl, Links = menuLinks.Concat(footerLinks), } }; using var aspNetProcess = project.StartPublishedProjectAsync(usePublishedAppHost: true); Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", project, aspNetProcess.Process)); await aspNetProcess.AssertPagesOk(pages); }
private async Task MvcTemplateBuildsAndPublishes(string auth, string[] args) { Project = await ProjectFactory.GetOrCreateProject("mvc" + Guid.NewGuid().ToString().Substring(0, 10).ToLower(), Output); var createResult = await Project.RunDotNetNewAsync("mvc", auth : auth, args : args); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", Project, createResult)); // Verify building in debug works 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. buildResult = await Project.RunDotNetPublishAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", Project, buildResult)); }
private async Task EmtpyTemplateCore(string languageOverride) { var project = await ProjectFactory.GetOrCreateProject("empty" + (languageOverride == "F#" ? "fsharp" : "csharp"), Output); var createResult = await project.RunDotNetNewAsync("web", language : languageOverride); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult)); // Avoid the F# compiler. See https://github.com/dotnet/aspnetcore/issues/14022 if (languageOverride != null) { return; } 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. var buildResult = await project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult)); using (var aspNetProcess = project.StartBuiltProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run built project", project, aspNetProcess.Process)); await aspNetProcess.AssertOk("/"); } using (var aspNetProcess = project.StartPublishedProjectAsync()) { Assert.False( aspNetProcess.Process.HasExited, ErrorMessages.GetFailedProcessMessageOrEmpty("Run published project", project, aspNetProcess.Process)); await aspNetProcess.AssertOk("/"); } }
public async Task BlazorWasmStandaloneTemplate_Works(BrowserKind browserKind) { // Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278 Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true"); var project = await ProjectFactory.GetOrCreateProject("blazorstandalone" + browserKind, Output); var createResult = await project.RunDotNetNewAsync("blazorwasm"); 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)); // The service worker assets manifest isn't generated for non-PWA projects var publishDir = Path.Combine(project.TemplatePublishDir, "wwwroot"); Assert.False(File.Exists(Path.Combine(publishDir, "service-worker-assets.js")), "Non-PWA templates should not produce service-worker-assets.js"); var buildResult = await project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult)); await BuildAndRunTest(project.ProjectName, project, browserKind); var(serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project); using (serveProcess) { Output.WriteLine($"Opening browser at {listeningUri}..."); if (Fixture.BrowserManager.IsAvailable(browserKind)) { await using var browser = await Fixture.BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo); var page = await NavigateToPage(browser, listeningUri); await TestBasicNavigation(project.ProjectName, page); } else { EnsureBrowserAvailable(browserKind); } } }
public async Task BlazorServerTemplat_IdentityWeb_BuildAndPublish(string auth, string[] args) { Project = await ProjectFactory.GetOrCreateProject("blazorserveridweb" + Guid.NewGuid().ToString().Substring(0, 10).ToLowerInvariant(), Output); var createResult = await Project.RunDotNetNewAsync("blazorserver", auth : auth, args : args); 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)); // 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 Project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", Project, buildResult)); }
public async Task RazorClassLibraryTemplateAsync() { Project = await ProjectFactory.GetOrCreateProject("razorclasslib", Output); var createResult = await Project.RunDotNetNewAsync("razorclasslib"); 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)); // 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 Project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", Project, buildResult)); }
public async Task SpaTemplates_BuildAndPublish(string projectKey, string template, string auth) { var project = await ProjectFactory.GetOrCreateProject(projectKey, Output); var args = new[] { "--NoSpaFrontEnd", "true" }; var createResult = await project.RunDotNetNewAsync(template, auth : auth, args : args); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage(template, project, createResult)); 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. var buildResult = await project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, createResult)); }
public async Task BlazorWasmTemplate_CreateBuildPublish_Hosted(BrowserKind browserKind) { // Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278 Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true"); var project = await ProjectFactory.GetOrCreateProject("blazorhosted" + browserKind, Output); var createResult = await project.RunDotNetNewAsync("blazorwasm", args : new[] { "--hosted" }); Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult)); var serverProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server"); var publishResult = await serverProject.RunDotNetPublishAsync(); Assert.True(0 == publishResult.ExitCode, ErrorMessages.GetFailedProcessMessage("publish", serverProject, publishResult)); var buildResult = await serverProject.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", serverProject, buildResult)); }
public async Task BlazorWasmStandaloneTemplate_IndividualAuth_Works(BrowserKind browserKind) { var project = await ProjectFactory.GetOrCreateProject("blazorstandaloneindividual" + browserKind, Output); // We don't want to test the auth flow as we don't have the required settings to talk to a third-party IdP // but we want to make sure that we are able to run the app without errors. // That will at least test that we are able to initialize and retrieve the configuration from the IdP // for that, we use the common microsoft tenant. await BuildAndRunTest(project.ProjectName, project, browserKind, usesAuth : false); var(serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project); using (serveProcess) { Output.WriteLine($"Opening browser at {listeningUri}..."); await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo); var page = await NavigateToPage(browser, listeningUri); await TestBasicNavigation(project.ProjectName, page); await page.CloseAsync(); } }
public async Task BlazorWasmHostedTemplate_AzureActiveDirectoryTemplate_Works(TemplateInstance instance) { var project = await ProjectFactory.GetOrCreateProject(instance.Name, Output); project.TargetFramework = "netstandard2.1"; var createResult = await project.RunDotNetNewAsync("blazorwasm", args : instance.Arguments); 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)); // 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 project.RunDotNetBuildAsync(); Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", project, buildResult)); }