/// <summary>
/// Authenticate against the F1 login page.
/// </summary>
/// <param name="login">Username/Email to authenticate with</param>
/// <param name="password">Password to authenticate with</param>
/// <param name="cancellationToken">Possible cancellation request token</param>
/// <returns>Authentication response values</returns>
/// <exception cref="AuthenticationException">Authentication failure exception</exception>
public async Task <AuthenticationResponse> AuthenticateAsync(string login, string password, CancellationToken cancellationToken = default)
{
#if DEBUG
_logger.LogTrace("Creating new page for authentication");
#endif
IPage page = await BrowserUtils.NewPageAsync(_browser, _random);
#if DEBUG
_logger.LogDebug("Created new page for authentication");
#endif
AuthenticationResponse response;
try
{
response = await AuthenticateAsync(page, login, password, cancellationToken)
.ConfigureAwait(false);
}
finally
{
#if DEBUG
_logger.LogTrace("Closing single-use page after authentication");
#endif
await page.CloseAsync()
.ConfigureAwait(false);
#if DEBUG
_logger.LogDebug("Closed single-use page after authentication");
#endif
}
return(response);
}
/// <summary>
/// Authenticate the sessionToken to retrieve F1TV authorization
/// </summary>
/// <param name="sessionToken">Session token provided by the AuthenticateResponse</param>
/// <param name="identityProvider">IdentityProvider (defaults to normal provider)</param>
/// <returns></returns>
public async Task <AuthenticationToken> AuthenticateF1TVTokenAsync(string sessionToken, string identityProvider = default)
{
#if DEBUG
_logger.LogTrace("Creating new page for F1TV token authentication");
#endif
IPage page = await BrowserUtils.NewPageAsync(_browser, _random)
.ConfigureAwait(false);
#if DEBUG
_logger.LogTrace("Created new page for F1TV token authentication");
#endif
AuthenticationToken response;
try
{
response = await AuthenticateF1TVTokenAsync(page, sessionToken, identityProvider)
.ConfigureAwait(false);
}
finally
{
#if DEBUG
_logger.LogTrace("Closing single-use page after authentication");
#endif
await page.CloseAsync()
.ConfigureAwait(false);
#if DEBUG
_logger.LogTrace("Closed single-use page after authentication");
#endif
}
return(response);
}
private async Task TryCaptureVideoAsync(
IPage page,
string testName,
string browserType)
{
if (!IsRunningInGitHubActions || page.Video is null)
{
return;
}
try
{
await page.CloseAsync();
string videoSource = await page.Video.PathAsync();
string?directory = Path.GetDirectoryName(videoSource);
string?extension = Path.GetExtension(videoSource);
string fileName = GenerateFileName(testName, browserType, extension !);
string videoDestination = Path.Combine(directory !, fileName);
File.Move(videoSource, videoDestination);
OutputHelper.WriteLine($"Video saved to {videoDestination}.");
}
#pragma warning disable CA1031
catch (Exception ex)
#pragma warning restore CA1031
{
OutputHelper.WriteLine("Failed to capture video: " + ex);
}
}
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 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);
}
}
public void Dispose()
{
page?.CloseAsync();
}
