public async Task ShouldBeAbleToReconnectToADisconnectedBrowser()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
await using var browser = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var context = await browser.NewContextAsync();
var page = await context.NewPageAsync();
await page.GoToAsync(TestConstants.EmptyPage);
await browser.CloseAsync();
await using var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
context = await remote.NewContextAsync();
page = await context.NewPageAsync();
await page.GoToAsync(TestConstants.EmptyPage);
await remote.CloseAsync();
await browserServer.CloseAsync();
}
public async Task ShouldSaveAsVideosFromRemoteBrowser()
{
using var tempDirectory = new TempDirectory();
var videoPath = tempDirectory.Path;
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var context = await browser.NewContextAsync(new()
{
RecordVideoDir = videoPath,
RecordVideoSize = new() { Height = 320, Width = 240 }
});
var page = await context.NewPageAsync();
await page.EvaluateAsync("() => document.body.style.backgroundColor = 'red'");
await Task.Delay(1000);
await context.CloseAsync();
var videoSavePath = tempDirectory.Path + "my-video.webm";
await page.Video.SaveAsAsync(videoSavePath);
Assert.That(videoSavePath, Does.Exist);
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(async() => await page.Video.PathAsync());
StringAssert.Contains("Path is not available when connecting remotely. Use SaveAsAsync() to save a local copy", exception.Message);
}
public async Task ShouldBeAbleToConnectTwoBrowsersAtTheSameTime()
{
var browser1 = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
Assert.AreEqual(browser1.Contexts.Count, 0);
await browser1.NewContextAsync();
Assert.AreEqual(browser1.Contexts.Count, 1);
var browser2 = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
Assert.AreEqual(browser2.Contexts.Count, 0);
await browser2.NewContextAsync();
Assert.AreEqual(browser2.Contexts.Count, 1);
Assert.AreEqual(browser1.Contexts.Count, 1);
await browser1.CloseAsync();
Assert.AreEqual(browser2.Contexts.Count, 1);
var page2 = await browser2.NewPageAsync();
Assert.AreEqual(await page2.EvaluateAsync <int>("7 * 6"), 42); // original browser should still work
await browser2.CloseAsync();
}
public async Task ShouldSaveDownload()
{
Server.SetRoute("/download", context =>
{
context.Response.Headers["Content-Type"] = "application/octet-stream";
context.Response.Headers["Content-Disposition"] = "attachment";
return(context.Response.WriteAsync("Hello world"));
});
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync(new() { AcceptDownloads = true });
await page.SetContentAsync($"<a href=\"{Server.Prefix}/download\">download</a>");
var downloadTask = page.WaitForDownloadAsync();
await TaskUtils.WhenAll(
downloadTask,
page.ClickAsync("a"));
using var tmpDir = new TempDirectory();
string userPath = Path.Combine(tmpDir.Path, "these", "are", "directories", "download.txt");
var download = downloadTask.Result;
await download.SaveAsAsync(userPath);
Assert.True(new FileInfo(userPath).Exists);
Assert.AreEqual("Hello world", File.ReadAllText(userPath));
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => download.PathAsync());
Assert.AreEqual("Path is not available when connecting remotely. Use SaveAsAsync() to save a local copy.", exception.Message);
await browser.CloseAsync();
}
public async Task ShouldRecordContextTraces()
{
using var tempDirectory = new TempDirectory();
var tracePath = tempDirectory.Path + "/trace.zip";
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var context = await browser.NewContextAsync();
var page = await context.NewPageAsync();
await context.Tracing.StartAsync(new() { Sources = true });
await page.GotoAsync(Server.EmptyPage);
await page.SetContentAsync("<button>Click</button>");
await page.ClickAsync("button");
await context.Tracing.StopAsync(new TracingStopOptions { Path = tracePath });
await browser.CloseAsync();
Assert.That(tracePath, Does.Exist);
ZipFile.ExtractToDirectory(tracePath, tempDirectory.Path);
Assert.That(tempDirectory.Path + "/trace.trace", Does.Exist);
Assert.That(tempDirectory.Path + "/trace.network", Does.Exist);
Assert.AreEqual(1, Directory.GetFiles(Path.Join(tempDirectory.Path, "resources"), "*.txt").Length);
}
public async Task ShouldErrorWhenSavingDownloadAfterDeletion()
{
Server.SetRoute("/download", context =>
{
context.Response.Headers["Content-Type"] = "application/octet-stream";
context.Response.Headers["Content-Disposition"] = "attachment";
return(context.Response.WriteAsync("Hello world"));
});
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync(new() { AcceptDownloads = true });
await page.SetContentAsync($"<a href=\"{Server.Prefix}/download\">download</a>");
var downloadTask = page.WaitForDownloadAsync();
await TaskUtils.WhenAll(
downloadTask,
page.ClickAsync("a"));
using var tmpDir = new TempDirectory();
string userPath = Path.Combine(tmpDir.Path, "download.txt");
var download = downloadTask.Result;
await download.DeleteAsync();
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(() => download.SaveAsAsync(userPath));
StringAssert.Contains("Target page, context or browser has been closed", exception.Message);
await browser.CloseAsync();
}
public async Task ShouldBeAbleToReconnectToABrowser()
{
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var browserContext = await browser.NewContextAsync();
Assert.AreEqual(browserContext.Pages.Count, 0);
var page = await browserContext.NewPageAsync();
Assert.AreEqual(await page.EvaluateAsync <int>("11 * 11"), 121);
await page.GotoAsync(Server.EmptyPage);
await browser.CloseAsync();
}
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var browserContext = await browser.NewContextAsync();
var page = await browserContext.NewPageAsync();
await page.GotoAsync(Server.EmptyPage);
await browser.CloseAsync();
}
}
public async Task ShouldSupportSlowMo()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint, new BrowserTypeConnectOptions { SlowMo = 200 });
var start = DateTime.Now;
var context = await browser.NewContextAsync();
await browser.CloseAsync();
Assert.Greater((DateTime.Now - start).TotalMilliseconds, 199);
}
public async Task ShouldSetTheBrowserConnectedState()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
Assert.True(remote.IsConnected);
await remote.CloseAsync();
Assert.False(remote.IsConnected);
}
public async Task ShouldRejectWaitForSelectorWhenBrowserCloses()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync();
var watchdog = page.WaitForSelectorAsync("div");
await browser.CloseAsync();
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(async() => await watchdog);
Assert.That(exception.Message, Contains.Substring("has been closed"));
}
public async Task ShouldSetTheBrowserConnectedState()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
Assert.AreEqual(browser.IsConnected, true);
var tsc = new TaskCompletionSource <bool>();
browser.Disconnected += (_, e) => tsc.SetResult(false);
_remoteServer.Close();
await tsc.Task;
Assert.AreEqual(browser.IsConnected, false);
}
public async Task ShouldNotThrowOnCloseAfterDisconnect()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync();
var tcs = new TaskCompletionSource <bool>();
browser.Disconnected += (_, e) => tcs.SetResult(true);
_remoteServer.Close();
await tcs.Task;
await browser.CloseAsync();
}
public async Task ShouldThrowIfUsedAfterDisconnect()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var page = await remote.NewPageAsync();
await remote.CloseAsync();
var exception = await Assert.ThrowsAnyAsync <PlaywrightSharpException>(() => page.EvaluateAsync("1 + 1"));
Assert.Contains("has been closed", exception.Message);
}
public async Task ShouldFireDisconnectedWhenClosingTheServer()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
await using var browser = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var disconnectedTcs = new TaskCompletionSource <bool>();
var closedTcs = new TaskCompletionSource <bool>();
browser.Disconnected += (server, e) => disconnectedTcs.TrySetResult(true);
browserServer.Closed += (server, e) => closedTcs.TrySetResult(true);
_ = browserServer.KillAsync();
await Task.WhenAll(disconnectedTcs.Task, closedTcs.Task).WithTimeout();
}
public async Task ShouldEmitCloseEventsOnPagesAndContexts()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var context = await remote.NewContextAsync();
var page = await context.NewPageAsync();
var tcs = new TaskCompletionSource <bool>();
page.Closed += (sender, e) => tcs.TrySetResult(true);
await Task.WhenAll(remote.CloseAsync(), tcs.Task);
}
public async Task ShouldThrowWhenWhenCallingWaitForNavigationAfterDisconnect()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync();
var tsc = new TaskCompletionSource <bool>();
browser.Disconnected += (_, e) => tsc.SetResult(false);
_remoteServer.Close();
await tsc.Task;
Assert.AreEqual(browser.IsConnected, false);
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(async() => await page.WaitForNavigationAsync());
StringAssert.Contains("Navigation failed because page was closed", exception.Message);
}
public async Task ShouldSendDefaultUserAgentAndPlaywrightBrowserHeadersWithConnectRequest()
{
var connectionRequest = Server.WaitForWebSocketConnectionRequest();
BrowserType.ConnectAsync($"ws://localhost:{Server.Port}/ws", new()
{
Headers = new Dictionary <string, string>()
{
["hello-foo"] = "i-am-bar",
}
}).IgnoreException();
var request = await connectionRequest;
StringAssert.Contains("Playwright", request.Headers["User-Agent"]);
Assert.AreEqual(request.Headers["hello-foo"], "i-am-bar");
Assert.AreEqual(request.Headers["x-playwright-browser"], BrowserType.Name);
}
public async Task ShouldThrowWhenUsedAfterIsConnectedReturnsFalse()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync();
var tsc = new TaskCompletionSource <bool>();
browser.Disconnected += (_, e) => tsc.SetResult(false);
_remoteServer.Close();
await tsc.Task;
Assert.AreEqual(browser.IsConnected, false);
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(async() => await page.EvaluateAsync("1 + 1"));
StringAssert.Contains("has been closed", exception.Message);
}
public async Task DisconnectedEventShouldHaveBrowserAsArguments()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
IBrowser disconneced = null;
var tsc = new TaskCompletionSource <object>();
browser.Disconnected += (_, browser) =>
{
disconneced = browser;
tsc.SetResult(null);
};
await browser.CloseAsync();
await tsc.Task;
Assert.AreEqual(browser, disconneced);
}
public async Task ShouldWork()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
await using var browser = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var browserContext = await browser.NewContextAsync();
Assert.Empty(browserContext.Pages);
Assert.NotEmpty(browserServer.WSEndpoint);
var page = await browserContext.NewPageAsync();
Assert.Equal(121, await page.EvaluateAsync <int>("11 * 11"));
await page.CloseAsync();
await browser.CloseAsync();
await browserServer.CloseAsync();
}
public async Task ShouldUploadLargeFile()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var context = await browser.NewContextAsync();
var page = await context.NewPageAsync();
await page.GotoAsync(Server.Prefix + "/input/fileupload.html");
using var tmpDir = new TempDirectory();
var filePath = Path.Combine(tmpDir.Path, "200MB");
using (var stream = File.OpenWrite(filePath))
{
var str = new string('a', 4 * 1024);
for (var i = 0; i < 50 * 1024; i++)
{
await stream.WriteAsync(Encoding.UTF8.GetBytes(str));
}
}
var input = page.Locator("input[type=file]");
var events = await input.EvaluateHandleAsync(@"e => {
const events = [];
e.addEventListener('input', () => events.push('input'));
e.addEventListener('change', () => events.push('change'));
return events;
}");
await input.SetInputFilesAsync(filePath);
Assert.AreEqual(await input.EvaluateAsync <string>("e => e.files[0].name"), "200MB");
Assert.AreEqual(await events.EvaluateAsync <string[]>("e => e"), new[] { "input", "change" });
var(file0Name, file0Size) = await TaskUtils.WhenAll(
Server.WaitForRequest("/upload", request => (request.Form.Files[0].FileName, request.Form.Files[0].Length)),
page.ClickAsync("input[type=submit]")
);
Assert.AreEqual("200MB", file0Name);
Assert.AreEqual(200 * 1024 * 1024, file0Size);
}
public async Task ShouldRejectNavigationWhenBrowserCloses()
{
Server.SetRoute("/one-style.css", context => Task.Delay(10000));
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var page = await remote.NewPageAsync();
var navigationTask = page.GoToAsync(TestConstants.ServerUrl + "/one-style.html", new GoToOptions
{
Timeout = 60000
});
await Server.WaitForRequest("/one-style.css");
await remote.CloseAsync();
await Assert.ThrowsAsync <NavigationException>(() => navigationTask);
}
public async Task ShouldRejectWaitForSelectorWhenBrowserCloses()
{
Server.SetRoute("/empty.html", context => Task.Delay(10000));
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var page = await remote.NewPageAsync();
var watchdog = page.WaitForSelectorAsync("div", new WaitForSelectorOptions {
State = WaitForState.Attached, Timeout = 60000
});
await page.WaitForSelectorAsync("body", new WaitForSelectorOptions { State = WaitForState.Attached });
await remote.CloseAsync();
await Assert.ThrowsAsync <TargetClosedException>(() => watchdog);
}
public async Task ShouldEmitCloseEventsOnPagesAndContexts()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var context = await browser.NewContextAsync();
var tsc = new TaskCompletionSource <object>();
context.Close += (_, e) => tsc.SetResult(null);
var page = await context.NewPageAsync();
bool pageClosed = false;
page.Close += (_, e) => pageClosed = true;
_remoteServer.Close();
await tsc.Task;
Assert.AreEqual(pageClosed, true);
}
public async Task ShouldThrowWhenUsedAfterIsConnectedReturnsFalse()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var page = await remote.NewPageAsync();
var disconnectedTask = new TaskCompletionSource <bool>();
remote.Disconnected += (sender, e) => disconnectedTask.TrySetResult(true);
await Task.WhenAll(browserServer.CloseAsync(), disconnectedTask.Task);
Assert.False(remote.IsConnected);
var exception = await Assert.ThrowsAnyAsync <PlaywrightSharpException>(() => page.EvaluateAsync("1 + 1"));
Assert.Contains("has been closed", exception.Message);
}
public async Task ShouldTerminateNetworkWaiters()
{
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync();
var requestWatchdog = page.WaitForRequestAsync(Server.EmptyPage);
var responseWatchog = page.WaitForResponseAsync(Server.EmptyPage);
_remoteServer.Close();
async Task CheckTaskHasException(Task task)
{
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(async() => await task);
StringAssert.Contains("Page closed", exception.Message);
StringAssert.DoesNotContain("Timeout", exception.Message);
}
await CheckTaskHasException(requestWatchdog);
await CheckTaskHasException(responseWatchog);
}
public async Task ShouldTerminateNetworkWaiters()
{
await using var browserServer = await BrowserType.LaunchServerAsync(TestConstants.GetDefaultBrowserOptions());
await using var remote = await BrowserType.ConnectAsync(new ConnectOptions { WSEndpoint = browserServer.WSEndpoint });
var newPage = await remote.NewPageAsync();
var requestTask = newPage.WaitForRequestAsync(TestConstants.EmptyPage);
var responseTask = newPage.WaitForResponseAsync(TestConstants.EmptyPage);
await browserServer.CloseAsync();
var exception = await Assert.ThrowsAsync <TargetClosedException>(() => requestTask);
Assert.Contains("Page closed", exception.Message);
Assert.DoesNotContain("Timeout", exception.Message);
exception = await Assert.ThrowsAsync <TargetClosedException>(() => responseTask);
Assert.Contains("Page closed", exception.Message);
Assert.DoesNotContain("Timeout", exception.Message);
}
public async Task ShouldSaveHar()
{
using var tempDirectory = new TempDirectory();
var harPath = tempDirectory.Path + "/test.har";
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var context = await browser.NewContextAsync(new()
{
RecordHarPath = harPath
});
var page = await context.NewPageAsync();
await page.GotoAsync(Server.EmptyPage);
await context.CloseAsync();
await browser.CloseAsync();
Assert.That(harPath, Does.Exist);
var logString = System.IO.File.ReadAllText(harPath);
StringAssert.Contains(Server.EmptyPage, logString);
}
public async Task DisconnectedEventShouldBeEmittedWhenBrowserIsClosedOrServerIsClosed()
{
var browser1 = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
await browser1.NewPageAsync();
var browser2 = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
await browser2.NewPageAsync();
int disconnected1 = 0;
int disconnected2 = 0;
browser1.Disconnected += (_, e) => disconnected1++;
browser2.Disconnected += (_, e) => disconnected2++;
var tsc1 = new TaskCompletionSource <object>();
browser1.Disconnected += (_, e) => tsc1.SetResult(null);
await browser1.CloseAsync();
await tsc1.Task;
Assert.AreEqual(disconnected1, 1);
Assert.AreEqual(disconnected2, 0);
var tsc2 = new TaskCompletionSource <object>();
browser2.Disconnected += (_, e) => tsc2.SetResult(null);
await browser2.CloseAsync();
await tsc2.Task;
Assert.AreEqual(disconnected1, 1);
Assert.AreEqual(disconnected2, 1);
}
public async Task ShouldRejectNavigationWhenBrowserCloses()
{
Server.SetRoute("/one-style.css", context =>
{
context.Response.Redirect("/one-style.css");
return(Task.CompletedTask);
});
var browser = await BrowserType.ConnectAsync(_remoteServer.WSEndpoint);
var page = await browser.NewPageAsync();
var PageGoto = page.GotoAsync(Server.Prefix + "/one-style.html", new PageGotoOptions {
Timeout = 60000
});
await Server.WaitForRequest("/one-style.css");
await browser.CloseAsync();
Assert.AreEqual(browser.IsConnected, false);
var exception = await PlaywrightAssert.ThrowsAsync <PlaywrightException>(async() => await PageGoto);
StringAssert.Contains("has been closed", exception.Message);
}