protected async Task BuildAndRunTest(string appName, Project project, BrowserKind browserKind, bool usesAuth = false)
{
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 (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(appName, page, usesAuth);
await page.CloseAsync();
}
else
{
EnsureBrowserAvailable(browserKind);
}
}
public async Task BlazorWasmHostedTemplate_Works(BrowserKind browserKind)
{
var project = await CreateBuildPublishAsync(args : new[] { "--hosted" }, serverProject : true);
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);
}
}
private async Task BlazorWasmHostedTemplate_IndividualAuth_Works(BrowserKind browserKind, bool useLocalDb)
{
var project = await CreateBuildPublishIndividualAuthProject(useLocalDb : useLocalDb);
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 BlazorWasmStandaloneTemplate_Works(BrowserKind browserKind)
{
var project = await CreateBuildPublishAsync();
// 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");
await BuildAndRunTest(project.ProjectName, project, browserKind);
var(serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project);
using (serveProcess)
{
Output.WriteLine($"Opening browser at {listeningUri}...");
if (BrowserManager.IsAvailable(browserKind))
{
await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
var page = await NavigateToPage(browser, listeningUri);
await TestBasicNavigation(project.ProjectName, page);
}
else
{
EnsureBrowserAvailable(browserKind);
}
}
}
public async Task BlazorWasmStandaloneTemplate_IndividualAuth_Works(BrowserKind browserKind)
{
var project = await CreateBuildPublishAsync("blazorstandaloneindividual" + browserKind, args : new[] {
"-au",
"Individual",
"--authority",
"https://login.microsoftonline.com/common/v2.0/.well-known/openid-configuration",
"--client-id",
"sample-client-id"
});
// 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();
}
}
// NOTE: BrowserKind argument must be first
public async Task DownloadFileFromAnchor(BrowserKind browserKind)
{
if (ShouldSkip(browserKind))
{
return;
}
// Arrange
var initialUrl = TestPage.Url;
var downloadTask = TestPage.WaitForEventAsync(PageEvent.Download);
// Act
await Task.WhenAll(
downloadTask,
TestPage.ClickAsync("a[download]"));
// Assert URL should still be same as before click
Assert.Equal(initialUrl, TestPage.Url);
// Assert that the resource was downloaded
var download = downloadTask.Result.Download;
Assert.Equal($"{_serverFixture.RootUri}subdir/images/blazor_logo_1000x.png", download.Url);
Assert.Equal("blazor_logo_1000x.png", download.SuggestedFilename);
}
/// <summary>
/// Creates a WebDriver instance for the desired browser using the specified proxy settings.
/// </summary>
/// <param name="kind">The browser to launch.</param>
/// <param name="proxy">The WebDriver Proxy object containing the proxy settings.</param>
/// <returns>A WebDriver instance using the specified proxy settings.</returns>
public static IWebDriver CreateWebDriverWithProxy(BrowserKind kind, Proxy proxy)
{
IWebDriver driver = null;
switch (kind)
{
case BrowserKind.InternetExplorer:
driver = CreateInternetExplorerDriverWithProxy(proxy);
break;
case BrowserKind.Firefox:
driver = CreateFirefoxDriverWithProxy(proxy);
break;
case BrowserKind.Chrome:
driver = CreateChromeDriverWithProxy(proxy);
break;
case BrowserKind.Edge:
driver = CreateEdgeDriverWithProxy(proxy);
break;
default:
driver = CreatePhantomJSDriverWithProxy(proxy);
break;
}
return(driver);
}
/// <summary>
/// Creates a WebDriver instance for the desired browser using the specified proxy settings.
/// </summary>
/// <param name="kind">The browser to launch.</param>
/// <param name="proxy">The WebDriver Proxy object containing the proxy settings.</param>
/// <returns>A WebDriver instance using the specified proxy settings.</returns>
public static IWebDriver CreateWebDriver(BrowserKind kind, Proxy proxy)
{
IWebDriver driver = null;
switch (kind)
{
case BrowserKind.InternetExplorer:
driver = CreateInternetExplorerDriverWithProxy(proxy);
break;
case BrowserKind.Firefox:
driver = CreateFirefoxDriverWithProxy(proxy);
break;
case BrowserKind.Chrome:
driver = CreateChromeDriverWithProxy(proxy);
break;
case BrowserKind.Edge:
throw new InvalidOperationException("Edge driver does not support proxies before Edge 75.");
case BrowserKind.Safari:
throw new InvalidOperationException("This demo app must be run on Windows, because of reliance on NTLM authentication.");
}
return(driver);
}
static void Main(string[] args)
{
// Note that we're using a port of 0, which tells Fiddler to
// select a random available port to listen on.
int proxyPort = StartFiddlerProxy(0);
// We are only proxying HTTP traffic, but could just as easily
// proxy HTTPS or FTP traffic.
OpenQA.Selenium.Proxy proxy = new OpenQA.Selenium.Proxy();
proxy.HttpProxy = string.Format("127.0.0.1:{0}", proxyPort);
// See the code of the individual methods for the details of how
// to create the driver instance with the proxy settings properly set.
BrowserKind browser = BrowserKind.Chrome;
//BrowserKind browser = BrowserKind.Firefox;
//BrowserKind browser = BrowserKind.IE;
//BrowserKind browser = BrowserKind.Edge;
//BrowserKind browser = BrowserKind.PhantomJS;
IWebDriver driver = WebDriverFactory.CreateWebDriverWithProxy(browser, proxy);
TestBasicAuth(driver);
driver.Quit();
StopFiddlerProxy();
Console.WriteLine("Complete! Press <Enter> to exit.");
Console.ReadLine();
}
public async Task BlazorWasmTemplate_CreateBuildPublish_Standalone(BrowserKind browserKind)
{
var project = await CreateBuildPublishAsync("blazorstandalone" + browserKind);
// 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");
}
protected void EnsureBrowserAvailable(BrowserKind browserKind)
{
Assert.False(
TryValidateBrowserRequired(
browserKind,
isRequired: !BrowserManager.IsExplicitlyDisabled(browserKind),
out var errorMessage),
errorMessage);
}
public Task BlazorWasmStandaloneTemplate_CreateBuildPublish_IndividualAuth(BrowserKind browserKind)
=> CreateBuildPublishAsync("blazorstandaloneindividual" + browserKind, args: new[] {
"-au",
"Individual",
"--authority",
"https://login.microsoftonline.com/common/v2.0/.well-known/openid-configuration",
"--client-id",
"sample-client-id"
});
public async Task BlazorServerTemplateWorks_IndividualAuth(BrowserKind browserKind, bool useLocalDB)
{
var project = await CreateBuildPublishAsync("blazorserverindividual" + browserKind + (useLocalDB ? "uld" : ""));
var browser = !BrowserManager.IsAvailable(browserKind) ?
null :
await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
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(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(page);
await page.CloseAsync();
}
else
{
EnsureBrowserAvailable(browserKind);
}
}
}
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 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);
}
}
private async Task <Project> CreateBuildPublishIndividualAuthProject(BrowserKind browserKind, bool useLocalDb)
{
// Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278
Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true");
var project = await CreateBuildPublishAsync("blazorhostedindividual" + browserKind + (useLocalDb ? "uld" : ""),
args : new[] { "--hosted", "-au", "Individual", useLocalDb ? "-uld" : "" });
var serverProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server");
var serverProjectFileContents = ReadFile(serverProject.TemplateOutputDir, $"{serverProject.ProjectName}.csproj");
if (!useLocalDb)
{
Assert.Contains(".db", serverProjectFileContents);
}
var appSettings = ReadFile(serverProject.TemplateOutputDir, "appsettings.json");
var element = JsonSerializer.Deserialize <JsonElement>(appSettings);
var clientsProperty = element.GetProperty("IdentityServer").EnumerateObject().Single().Value.EnumerateObject().Single();
var replacedSection = element.GetRawText().Replace(clientsProperty.Name, serverProject.ProjectName.Replace(".Server", ".Client"));
var appSettingsPath = Path.Combine(serverProject.TemplateOutputDir, "appsettings.json");
File.WriteAllText(appSettingsPath, replacedSection);
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.
var buildResult = await serverProject.RunDotNetBuildAsync();
Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", serverProject, buildResult));
var migrationsResult = await serverProject.RunDotNetEfCreateMigrationAsync("blazorwasm");
Assert.True(0 == migrationsResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", serverProject, migrationsResult));
serverProject.AssertEmptyMigration("blazorwasm");
if (useLocalDb)
{
var dbUpdateResult = await serverProject.RunDotNetEfUpdateDatabaseAsync();
Assert.True(0 == dbUpdateResult.ExitCode, ErrorMessages.GetFailedProcessMessage("update database", serverProject, dbUpdateResult));
}
return(project);
}
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 static AuthenticationTest CreateTest(AuthenticationKind testType, BrowserKind browser)
{
switch (testType)
{
case AuthenticationKind.Basic:
return(new BasicAuthenticationTest(browser));
case AuthenticationKind.Digest:
return(new DigestAuthenticationTest(browser));
default:
return(new NtlmAuthenticationTest(browser));
}
}
/// <summary>
/// Main entry point of the application.
/// </summary>
/// <param name="args">Command line arguments of the application.</param>
static void Main(string[] args)
{
BrowserKind browserKind = BrowserKind.Chrome;
PageObjectPatternExamples pageObjectPatternExamples = new PageObjectPatternExamples(browserKind);
pageObjectPatternExamples.TestSuccessfulLogin();
pageObjectPatternExamples.TestUnsuccessfulUserNameLogin();
pageObjectPatternExamples.TestUnsuccessfulPasswordLogin();
Console.WriteLine("Complete! Press <Enter> to exit.");
Console.ReadLine();
}
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 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);
}
}
}
/// <summary>
/// Initializes the browser.
/// </summary>
/// <param name="kind">The browser kind.</param>
/// <returns>The web driver.</returns>
public static IWebDriver Initialize(BrowserKind kind)
{
if (!s_initialized)
{
LogHelper.Log("Initializing browser...");
var driversFolder = AppConfig.BrowserDriverFolder;
var proxy = new Proxy();
switch (kind)
{
case BrowserKind.Chrome:
Current = new ChromeBrowser();
break;
case BrowserKind.Firefox:
Current = new FirefoxBrowser();
break;
case BrowserKind.IE:
Current = new IEBrowser();
break;
case BrowserKind.PhantomJS:
Current = new PhantomJSBrowser();
break;
default:
throw new InvalidOperationException("Browser {0} not supported.".With(kind));
}
LogHelper.Log("{0} selected.", kind);
ExecutionEvents.RaiseBrowserInitializing();
Current.Initialize(driversFolder, proxy);
LogHelper.Log("Browser initialized.");
s_initialized = true;
ExecutionEvents.RaiseBrowserInitialized();
}
return Current.Driver;
}
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));
}
// NOTE: BrowserKind argument must be first
public async Task CanSendAndReceiveBytes(BrowserKind browserKind)
{
if (ShouldSkip(browserKind))
{
return;
}
var targetUri = new Uri(_apiServerFixture.RootUri, "/subdir/api/data");
await TestPage.TypeAsync("#request-uri", targetUri.AbsoluteUri);
await TestPage.ClickAsync("#send-request");
var status = await TestPage.GetTextContentAsync("#response-status");
var statusText = await TestPage.GetTextContentAsync("#response-status-text");
var testOutcome = await TestPage.GetTextContentAsync("#test-outcome");
Assert.Equal("OK", status);
Assert.Equal("OK", statusText);
Assert.Equal("", testOutcome);
}
public Dictionary <string, object> Capabilities(BrowserKind browserKind)
{
string browserCapabilities = string.Empty;
switch (browserKind)
{
case BrowserKind.Auto:
browserCapabilities = "ChromeCapabilities";
break;
case BrowserKind.Chrome:
browserCapabilities = "ChromeCapabilities";
break;
case BrowserKind.Firefox:
browserCapabilities = "FirefoxCapabilities";
break;
case BrowserKind.operablink:
browserCapabilities = "OperaCapabilities";
break;
case BrowserKind.MicrosoftEdge:
browserCapabilities = "EdgeCapabilities";
break;
}
var path = ResolveFilePath("seleniumSettings.json");
using (var file = File.OpenText(path))
{
var text = file.ReadToEnd();
var parsedSettings = JObject.Parse(text);
var capabilities = parsedSettings[Configuration[$"RemoteBrowserSettings:{browserCapabilities}"]];
return(JsonDeserializer.GetDictionaryFromJObject((JObject)capabilities));
}
}
public async Task BlazorWasmStandaloneTemplate_Works(BrowserKind browserKind)
{
var project = await ProjectFactory.GetOrCreateProject("blazorstandalone" + browserKind, Output);
await BuildAndRunTest(project.ProjectName, project, browserKind);
var(serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project);
using (serveProcess)
{
Output.WriteLine($"Opening browser at {listeningUri}...");
if (BrowserManager.IsAvailable(browserKind))
{
await using var browser = await BrowserManager.GetBrowserInstance(browserKind, BrowserContextInfo);
var page = await NavigateToPage(browser, listeningUri);
await TestBasicNavigation(project.ProjectName, page);
}
else
{
EnsureBrowserAvailable(browserKind);
}
}
}
public async Task BlazorWasmStandalonePwaTemplate_Works(BrowserKind browserKind)
{
var project = await ProjectFactory.GetOrCreateProject("blazorstandalonepwa", Output);
await BuildAndRunTest(project.ProjectName, project, browserKind);
ValidatePublishedServiceWorker(project);
if (BrowserManager.IsAvailable(browserKind))
{
var(serveProcess, listeningUri) = RunPublishedStandaloneBlazorProject(project);
await using var browser = await 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);
}
}
/// <summary>
/// Creates a WebDriver instance for the desired browser using the specified proxy settings.
/// </summary>
/// <param name="kind">The browser to launch.</param>
/// <param name="proxy">The WebDriver Proxy object containing the proxy settings.</param>
/// <returns>A WebDriver instance using the specified proxy settings.</returns>
public static IWebDriver CreateWebDriverWithProxy(BrowserKind kind, Proxy proxy)
{
IWebDriver driver = null;
switch (kind)
{
case BrowserKind.InternetExplorer:
driver = CreateInternetExplorerDriverWithProxy(proxy);
break;
case BrowserKind.Firefox:
driver = CreateFirefoxDriverWithProxy(proxy);
break;
case BrowserKind.Chrome:
driver = CreateChromeDriverWithProxy(proxy);
break;
default:
driver = CreatePhantomJSDriverWithProxy(proxy);
break;
}
return driver;
}
/// <summary>
/// Initializes a new instance of the <see cref="BrowserBase"/> class.
/// </summary>
/// <param name="kind">The browser kind.</param>
/// <param name="processName">The name of the browser process.</param>
protected BrowserBase(BrowserKind kind, string processName)
{
Kind = kind;
m_processName = processName;
WaitMilliseconds = 0;
}
private async Task BlazorWasmHostedTemplate_IndividualAuth_Works(BrowserKind browserKind, bool useLocalDb)
{
// Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278
Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true");
var project = await ProjectFactory.GetOrCreateProject("blazorhostedindividual" + browserKind + (useLocalDb ? "uld" : ""), Output);
var createResult = await project.RunDotNetNewAsync("blazorwasm", args : new[] { "--hosted", "-au", "Individual", useLocalDb ? "-uld" : "" });
Assert.True(0 == createResult.ExitCode, ErrorMessages.GetFailedProcessMessage("create/restore", project, createResult));
var serverProject = GetSubProject(project, "Server", $"{project.ProjectName}.Server");
var serverProjectFileContents = ReadFile(serverProject.TemplateOutputDir, $"{serverProject.ProjectName}.csproj");
if (!useLocalDb)
{
Assert.Contains(".db", serverProjectFileContents);
}
var appSettings = ReadFile(serverProject.TemplateOutputDir, "appsettings.json");
var element = JsonSerializer.Deserialize <JsonElement>(appSettings);
var clientsProperty = element.GetProperty("IdentityServer").EnumerateObject().Single().Value.EnumerateObject().Single();
var replacedSection = element.GetRawText().Replace(clientsProperty.Name, serverProject.ProjectName.Replace(".Server", ".Client"));
var appSettingsPath = Path.Combine(serverProject.TemplateOutputDir, "appsettings.json");
File.WriteAllText(appSettingsPath, replacedSection);
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.
var buildResult = await serverProject.RunDotNetBuildAsync();
Assert.True(0 == buildResult.ExitCode, ErrorMessages.GetFailedProcessMessage("build", serverProject, buildResult));
var migrationsResult = await serverProject.RunDotNetEfCreateMigrationAsync("blazorwasm");
Assert.True(0 == migrationsResult.ExitCode, ErrorMessages.GetFailedProcessMessage("run EF migrations", serverProject, migrationsResult));
serverProject.AssertEmptyMigration("blazorwasm");
if (useLocalDb)
{
var dbUpdateResult = await serverProject.RunDotNetEfUpdateDatabaseAsync();
Assert.True(0 == dbUpdateResult.ExitCode, ErrorMessages.GetFailedProcessMessage("update database", serverProject, dbUpdateResult));
}
await BuildAndRunTest(project.ProjectName, serverProject, browserKind, usesAuth : true);
UpdatePublishedSettings(serverProject);
if (Fixture.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 Fixture.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 Task BlazorWasmHostedTemplate_IndividualAuth_Works_WithOutLocalDB(BrowserKind browserKind)
{
return(BlazorWasmHostedTemplate_IndividualAuth_Works(browserKind, false));
}
public async Task BlazorWasmHostedPwaTemplate_Works(BrowserKind browserKind)
{
// Additional arguments are needed. See: https://github.com/dotnet/aspnetcore/issues/24278
Environment.SetEnvironmentVariable("EnableDefaultScopedCssItems", "true");
var project = await ProjectFactory.GetOrCreateProject("blazorhostedpwa", Output);
var createResult = await project.RunDotNetNewAsync("blazorwasm", args : new[] { "--hosted", "--pwa" });
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);
ValidatePublishedServiceWorker(serverProject);
string listeningUri = null;
if (Fixture.BrowserManager.IsAvailable(browserKind))
{
await using var browser = await Fixture.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);
}
}
