merge: resolve conflicts with master (issues support + extension realms)

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: kblok

lib/PuppeteerSharp.Nunit/TestExpectations/TestExpectations.upstream.json

@@ -1367,6 +1367,21 @@
     ],
     "comment": "Flaky on Mac"
   },
+  {
+    "testIdPattern": "[page.spec] Page Page.Events.Issue *",
+    "platforms": [
+      "darwin",
+      "linux",
+      "win32"
+    ],
+    "parameters": [
+      "webDriverBiDi"
+    ],
+    "expectations": [
+      "SKIP"
+    ],
+    "comment": "BiDi does not support issue events"
+  },
   {
     "testIdPattern": "[page.spec] Page Page.Events.error should throw when page crashes",
     "platforms": [
@@ -3933,6 +3948,13 @@
     ],
     "comment": "TODO: add a comment explaining why this expectation is required (include links to issues)"
   },
+  {
+    "testIdPattern": "[worker.spec] Workers console should return remote objects",
+    "platforms": ["darwin", "linux", "win32"],
+    "parameters": ["webDriverBiDi"],
+    "expectations": ["FAIL"],
+    "comment": "BiDi does not support getting a Handle for log args"
+  },
   {
     "testIdPattern": "[worker.spec] Workers should report errors",
     "platforms": [

lib/PuppeteerSharp.Tests/PageTests/PageEventsIssueTests.cs

@@ -0,0 +1,70 @@
+using System.Threading.Tasks;
+using NUnit.Framework;
+using PuppeteerSharp.Nunit;
+
+namespace PuppeteerSharp.Tests.PageTests;
+
+public class PageEventsIssueTests : PuppeteerPageBaseTest
+{
+    [Test, PuppeteerTest("page.spec", "Page Page.Events.Issue", "should emit issue event when CSP violation occurs")]
+    public async Task ShouldEmitIssueEventWhenCspViolationOccurs()
+    {
+        await Page.GoToAsync(TestConstants.ServerUrl + "/csp.html");
+
+        var issueTask = new TaskCompletionSource<Issue>();
+        Page.Issue += (_, e) => issueTask.TrySetResult(e.Issue);
+
+        await Page.AddScriptTagAsync(new AddTagOptions { Content = "console.log(\"CSP test\")" });
+
+        var issue = await issueTask.Task;
+        Assert.That(issue, Is.Not.Null);
+        Assert.That(issue.Code, Is.EqualTo("ContentSecurityPolicyIssue"));
+    }
+
+    [Test, PuppeteerTest("page.spec", "Page Page.Events.Issue", "should emit issue event from cross-origin iframe")]
+    public async Task ShouldEmitIssueEventFromCrossOriginIframe()
+    {
+        await Page.GoToAsync(TestConstants.EmptyPage);
+
+        var cspIssueTask = new TaskCompletionSource<Issue>();
+        Page.Issue += (_, e) =>
+        {
+            if (e.Issue.Code == "ContentSecurityPolicyIssue")
+            {
+                cspIssueTask.TrySetResult(e.Issue);
+            }
+        };
+
+        var crossOriginUrl = TestConstants.CrossProcessUrl + "/csp.html";
+        await Page.SetContentAsync($"<iframe src=\"{crossOriginUrl}\"></iframe>");
+
+        var frame = await Page.WaitForFrameAsync(crossOriginUrl);
+        Assert.That(frame, Is.Not.Null);
+
+        await frame.AddScriptTagAsync(new AddTagOptions { Content = "console.log(\"CSP test in iframe\")" });
+
+        var issue = await cspIssueTask.Task;
+        Assert.That(issue, Is.Not.Null);
+        Assert.That(issue.Code, Is.EqualTo("ContentSecurityPolicyIssue"));
+    }
+}
+
+public class PageEventsIssueDisabledTests : PuppeteerPageBaseTest
+{
+    public PageEventsIssueDisabledTests()
+    {
+        DefaultOptions = TestConstants.DefaultBrowserOptions();
+        DefaultOptions.IssuesEnabled = false;
+    }
+
+    [Test, PuppeteerTest("page.spec", "Page Page.Events.Issue when issues are disabled", "should be able to connect and disable issues")]
+    public async Task ShouldBeAbleToConnectAndDisableIssues()
+    {
+        var issueEmitted = false;
+        Page.Issue += (_, _) => issueEmitted = true;
+
+        await Page.GoToAsync(TestConstants.ServerUrl + "/csp.html");
+
+        Assert.That(issueEmitted, Is.False);
+    }
+}

lib/PuppeteerSharp.Tests/UtilitiesTests/ScreenshotMutexTests.cs

@@ -0,0 +1,66 @@
+using System;
+using System.Threading.Tasks;
+using NUnit.Framework;
+using PuppeteerSharp.Helpers;
+
+namespace PuppeteerSharp.Tests.UtilitiesTests
+{
+    public class ScreenshotMutexTests
+    {
+        [Test]
+        public async Task ShouldLockAndRelease()
+        {
+            var mutex = new ScreenshotMutex();
+            var guard = await mutex.AcquireAsync();
+            Assert.That(guard, Is.Not.Null);
+            guard.Dispose();
+        }
+
+        [Test]
+        public async Task ShouldWorkSequentially()
+        {
+            var mutex = new ScreenshotMutex();
+            var results = new System.Collections.Generic.List<int>();
+            var first = await mutex.AcquireAsync();
+            var secondTask = mutex.AcquireAsync();
+
+            _ = Task.Delay(10).ContinueWith(_ =>
+            {
+                results.Add(1);
+                first.Dispose();
+            });
+
+            var second = await secondTask;
+            results.Add(2);
+            second.Dispose();
+
+            Assert.That(results, Is.EqualTo(new[] { 1, 2 }));
+        }
+
+        [Test]
+        public async Task ShouldCallOnReleaseWhenDisposed()
+        {
+            var mutex = new ScreenshotMutex();
+            var onReleaseCalled = false;
+            var guard = await mutex.AcquireAsync(() => onReleaseCalled = true);
+            guard.Dispose();
+            Assert.That(onReleaseCalled, Is.True);
+        }
+
+        [Test]
+        public async Task ShouldCallOnReleaseWhenDisposedForQueuedAcquirers()
+        {
+            var mutex = new ScreenshotMutex();
+            var first = await mutex.AcquireAsync();
+
+            var onReleaseCalled = false;
+            var secondTask = mutex.AcquireAsync(() => onReleaseCalled = true);
+
+            first.Dispose();
+            var second = await secondTask;
+
+            second.Dispose();
+            Assert.That(onReleaseCalled, Is.True);
+        }
+    }
+}

lib/PuppeteerSharp.Tests/WorkerTests/PageWorkerTests.cs

@@ -1,3 +1,4 @@
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using NUnit.Framework;
 using PuppeteerSharp.Helpers;
@@ -11,6 +12,14 @@ public PageWorkerTests() : base()
         {
         }
 
+        private async Task<WebWorker> CreateWorkerAsync()
+        {
+            var workerCreatedTcs = new TaskCompletionSource<WebWorker>();
+            Page.WorkerCreated += (_, e) => workerCreatedTcs.TrySetResult(e.Worker);
+            await Page.EvaluateFunctionAsync("() => new Worker('data:text/javascript,1')");
+            return await workerCreatedTcs.Task;
+        }
+
         [Test, PuppeteerTest("worker.spec", "Workers", "Page.workers")]
         [Ignore("TODO: Fix me. Too flaky")]
         public async Task PageWorkers()
@@ -134,6 +143,174 @@ public async Task CanBeClosed()
             Assert.That(await workerClosedTcs.Task, Is.SameAs(worker));
         }
 
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should work")]
+        public async Task ConsoleShouldWork()
+        {
+            var worker = await CreateWorkerAsync();
+            var consoleTcs = new TaskCompletionSource<ConsoleMessage>();
+            worker.Console += (_, e) => consoleTcs.TrySetResult(e.Message);
+
+            await worker.EvaluateFunctionAsync("() => console.log('hello', 5, {foo: 'bar'})");
+
+            var message = await consoleTcs.Task.WithTimeout();
+            Assert.That(message.Text, Does.Contain("hello").And.Contain("5"));
+            Assert.That(message.Type, Is.EqualTo(ConsoleType.Log));
+            Assert.That(message.Args, Has.Count.EqualTo(3));
+            Assert.That(await message.Args[0].JsonValueAsync<string>(), Is.EqualTo("hello"));
+            Assert.That(await message.Args[1].JsonValueAsync<int>(), Is.EqualTo(5));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should work for Error instances")]
+        public async Task ConsoleShouldWorkForErrorInstances()
+        {
+            var worker = await CreateWorkerAsync();
+            var consoleTcs = new TaskCompletionSource<ConsoleMessage>();
+            worker.Console += (_, e) => consoleTcs.TrySetResult(e.Message);
+
+            await worker.EvaluateFunctionAsync("() => console.log(new Error('test error'))");
+
+            var message = await consoleTcs.Task.WithTimeout();
+            Assert.That(message.Text, Does.Contain("test error").Or.EqualTo("JSHandle@error"));
+            Assert.That(message.Type, Is.EqualTo(ConsoleType.Log));
+            Assert.That(message.Args, Has.Count.EqualTo(1));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should return the first line of the error message in text()")]
+        public async Task ConsoleShouldReturnFirstLineOfErrorMessageInText()
+        {
+            var worker = await CreateWorkerAsync();
+            var consoleTcs = new TaskCompletionSource<ConsoleMessage>();
+            worker.Console += (_, e) => consoleTcs.TrySetResult(e.Message);
+
+            await worker.EvaluateFunctionAsync("() => console.log(new Error('test error\\nsecond line'))");
+
+            var message = await consoleTcs.Task.WithTimeout();
+            Assert.That(message.Text, Does.Contain("test error").Or.EqualTo("JSHandle@error"));
+            Assert.That(message.Type, Is.EqualTo(ConsoleType.Log));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should work for console.trace")]
+        public async Task ConsoleShouldWorkForConsoleTrace()
+        {
+            var worker = await CreateWorkerAsync();
+            var consoleTcs = new TaskCompletionSource<ConsoleMessage>();
+            worker.Console += (_, e) => consoleTcs.TrySetResult(e.Message);
+
+            await worker.EvaluateFunctionAsync("() => console.trace('calling console.trace')");
+
+            var message = await consoleTcs.Task.WithTimeout();
+            Assert.That(message.Type, Is.EqualTo(ConsoleType.Trace));
+            Assert.That(message.Text, Is.EqualTo("calling console.trace"));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should work for console.dir")]
+        public async Task ConsoleShouldWorkForConsoleDir()
+        {
+            var worker = await CreateWorkerAsync();
+            var consoleTcs = new TaskCompletionSource<ConsoleMessage>();
+            worker.Console += (_, e) => consoleTcs.TrySetResult(e.Message);
+
+            await worker.EvaluateFunctionAsync("() => console.dir('calling console.dir')");
+
+            var message = await consoleTcs.Task.WithTimeout();
+            Assert.That(message.Type, Is.EqualTo(ConsoleType.Dir));
+            Assert.That(message.Text, Is.EqualTo("calling console.dir"));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should work for console.warn")]
+        public async Task ConsoleShouldWorkForConsoleWarn()
+        {
+            var worker = await CreateWorkerAsync();
+            var consoleTcs = new TaskCompletionSource<ConsoleMessage>();
+            worker.Console += (_, e) => consoleTcs.TrySetResult(e.Message);
+
+            await worker.EvaluateFunctionAsync("() => console.warn('calling console.warn')");
+
+            var message = await consoleTcs.Task.WithTimeout();
+            Assert.That(message.Type, Is.EqualTo(ConsoleType.Warning));
+            Assert.That(message.Text, Is.EqualTo("calling console.warn"));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should work for console.error")]
+        public async Task ConsoleShouldWorkForConsoleError()
+        {
+            var worker = await CreateWorkerAsync();
+            var consoleTcs = new TaskCompletionSource<ConsoleMessage>();
+            worker.Console += (_, e) => consoleTcs.TrySetResult(e.Message);
+
+            await worker.EvaluateFunctionAsync("() => console.error('calling console.error')");
+
+            var message = await consoleTcs.Task.WithTimeout();
+            Assert.That(message.Type, Is.EqualTo(ConsoleType.Error));
+            Assert.That(message.Text, Is.EqualTo("calling console.error"));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should work for console.log with promise")]
+        public async Task ConsoleShouldWorkForConsoleLogWithPromise()
+        {
+            var worker = await CreateWorkerAsync();
+            var consoleTcs = new TaskCompletionSource<ConsoleMessage>();
+            worker.Console += (_, e) => consoleTcs.TrySetResult(e.Message);
+
+            await worker.EvaluateFunctionAsync("() => console.log(Promise.resolve('should not wait until resolved!'))");
+
+            var message = await consoleTcs.Task.WithTimeout();
+            Assert.That(message.Type, Is.EqualTo(ConsoleType.Log));
+            Assert.That(message.Text, Does.Contain("promise").Or.Contain("Promise"));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should work for different console API calls with timing functions")]
+        public async Task ConsoleShouldWorkForTimingFunctions()
+        {
+            var worker = await CreateWorkerAsync();
+            var messages = new List<ConsoleMessage>();
+            worker.Console += (_, e) => messages.Add(e.Message);
+
+            await worker.EvaluateFunctionAsync(@"() => {
+                console.time('calling console.time');
+                console.timeEnd('calling console.time');
+            }");
+
+            Assert.That(messages, Has.Count.EqualTo(1));
+            Assert.That(messages[0].Type, Is.EqualTo(ConsoleType.TimeEnd));
+            Assert.That(messages[0].Text, Does.Contain("calling console.time"));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should work for different console API calls with group functions")]
+        public async Task ConsoleShouldWorkForGroupFunctions()
+        {
+            var worker = await CreateWorkerAsync();
+            var messages = new List<ConsoleMessage>();
+            worker.Console += (_, e) => messages.Add(e.Message);
+
+            await worker.EvaluateFunctionAsync(@"() => {
+                console.group('calling console.group');
+                console.groupEnd();
+            }");
+
+            Assert.That(messages, Has.Count.EqualTo(2));
+            Assert.That(messages[0].Type, Is.EqualTo(ConsoleType.StartGroup));
+            Assert.That(messages[1].Type, Is.EqualTo(ConsoleType.EndGroup));
+            Assert.That(messages[0].Text, Does.Contain("calling console.group"));
+        }
+
+        [Test, PuppeteerTest("worker.spec", "Workers console", "should return remote objects")]
+        public async Task ConsoleShouldReturnRemoteObjects()
+        {
+            var worker = await CreateWorkerAsync();
+            var consoleTcs = new TaskCompletionSource<ConsoleMessage>();
+            worker.Console += (_, e) => consoleTcs.TrySetResult(e.Message);
+
+            await worker.EvaluateFunctionAsync(@"() => {
+                globalThis.test = 1;
+                console.log(1, 2, 3, globalThis);
+            }");
+
+            var message = await consoleTcs.Task.WithTimeout();
+            Assert.That(message.Text, Does.Contain("1 2 3"));
+            Assert.That(message.Args, Has.Count.EqualTo(4));
+        }
+
         [Test, PuppeteerTest("worker.spec", "Workers", "should work with waitForNetworkIdle")]
         public async Task ShouldWorkWithWaitForNetworkIdle()
         {

lib/PuppeteerSharp/Bidi/BidiBrowser.cs

@@ -47,13 +47,15 @@ public class BidiBrowser : Browser
     private readonly BidiBrowserTarget _target;
     private readonly string _webSocketEndpoint;
     private readonly bool _networkEnabled;
+    private readonly bool _issuesEnabled;
     private bool _isClosed;
 
     private BidiBrowser(Core.Browser browserCore, IBrowserOptions options, ILoggerFactory loggerFactory, string webSocketEndpoint)
     {
         _target = new BidiBrowserTarget(this);
         _options = options;
         _networkEnabled = options.NetworkEnabled;
+        _issuesEnabled = options.IssuesEnabled;
         BrowserCore = browserCore;
         _webSocketEndpoint = webSocketEndpoint;
         _logger = loggerFactory.CreateLogger<BidiBrowser>();
@@ -386,6 +388,8 @@ await driver.Network.AddDataCollectorAsync(
 
     internal override bool IsNetworkEnabled() => _networkEnabled;
 
+    internal override bool IsIssuesEnabled() => _issuesEnabled;
+
     private static WindowState MapFromClientWindowState(WebDriverBiDi.Browser.ClientWindowState state) => state switch
     {
         WebDriverBiDi.Browser.ClientWindowState.Normal => WindowState.Normal,