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); }