Implement upstream PR #14784: console event on WebWorkers (#3408)

kblok · claude · web-flow · commit 7ecf0b7ed6fe · 2026-04-21T07:53:54.000-03:00
* Implement upstream PR #14784: console event on WebWorkers Ports puppeteer/puppeteer#14784 to PuppeteerSharp. Adds Console event to WebWorker, wired up in CdpWebWorker and BidiWorkerRealm. Adds DedicatedWorkerRealm.Log event filtered by realm ID. Adds 11 console tests under Workers > console describe. Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * fix: remove invalid event access from subclass; fix describe chain - Remove if (Console != null) check in CdpWebWorker since events can only be accessed from their declaring class (CS0070) - Fix PuppeteerTest describe chain from 'Workers > console' to 'Workers console' Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> * Fix CS0070, CS0103, SA1204 in BidiWorkerRealm - Add WebDriverBiDi.Script using for RemoteValueType - Remove invalid Console null-check (CS0070: can only be done in declaring class) - Move static methods before instance methods (SA1204) Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com> --------- Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>
diff --git a/lib/PuppeteerSharp.Nunit/TestExpectations/TestExpectations.upstream.json b/lib/PuppeteerSharp.Nunit/TestExpectations/TestExpectations.upstream.json
@@ -3933,6 +3933,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": [
diff --git a/lib/PuppeteerSharp.Tests/WorkerTests/PageWorkerTests.cs b/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()
         {
diff --git a/lib/PuppeteerSharp/Bidi/BidiWorkerRealm.cs b/lib/PuppeteerSharp/Bidi/BidiWorkerRealm.cs
@@ -22,9 +22,12 @@
 
 #if !CDP_ONLY
 
+using System.Collections.Generic;
+using System.Linq;
 using System.Threading.Tasks;
 using PuppeteerSharp.Bidi.Core;
 using PuppeteerSharp.Helpers;
+using WebDriverBiDi.Script;
 
 namespace PuppeteerSharp.Bidi;
 
@@ -85,10 +88,99 @@ protected override void Initialize()
         _realm.Destroyed += (sender, args) => Dispose();
         _realm.Updated += (sender, args) =>
         {
-            // Reset PuppeteerUtil when the realm is updated
             _puppeteerUtil = null;
             TaskManager.RerunAll();
         };
+        _realm.Log += OnLog;
+    }
+
+    private static ConsoleType ConvertConsoleMessageLevel(string method) => method switch
+    {
+        "group" => ConsoleType.StartGroup,
+        "groupCollapsed" => ConsoleType.StartGroupCollapsed,
+        "groupEnd" => ConsoleType.EndGroup,
+        "log" => ConsoleType.Log,
+        "debug" => ConsoleType.Debug,
+        "info" => ConsoleType.Info,
+        "error" => ConsoleType.Error,
+        "warn" => ConsoleType.Warning,
+        "dir" => ConsoleType.Dir,
+        "dirxml" => ConsoleType.Dirxml,
+        "table" => ConsoleType.Table,
+        "trace" => ConsoleType.Trace,
+        "clear" => ConsoleType.Clear,
+        "assert" => ConsoleType.Assert,
+        "profile" => ConsoleType.Profile,
+        "profileEnd" => ConsoleType.ProfileEnd,
+        "count" => ConsoleType.Count,
+        "timeEnd" => ConsoleType.TimeEnd,
+        "verbose" => ConsoleType.Verbose,
+        "timeStamp" => ConsoleType.Timestamp,
+        _ => ConsoleType.Log,
+    };
+
+    private static ConsoleMessageLocation GetStackTraceLocation(StackTrace stackTrace)
+    {
+        if (stackTrace?.CallFrames?.Count > 0)
+        {
+            var callFrame = stackTrace.CallFrames[0];
+            return new ConsoleMessageLocation
+            {
+                URL = callFrame.Url,
+                LineNumber = (int)callFrame.LineNumber,
+                ColumnNumber = (int)callFrame.ColumnNumber,
+            };
+        }
+
+        return null;
+    }
+
+    private static IList<ConsoleMessageLocation> GetStackTrace(StackTrace stackTrace)
+    {
+        if (stackTrace?.CallFrames?.Count > 0)
+        {
+            return stackTrace.CallFrames.Select(callFrame => new ConsoleMessageLocation
+            {
+                URL = callFrame.Url,
+                LineNumber = (int)callFrame.LineNumber,
+                ColumnNumber = (int)callFrame.ColumnNumber,
+            }).ToList();
+        }
+
+        return [];
+    }
+
+    private void OnLog(object sender, WebDriverBiDi.Log.EntryAddedEventArgs args)
+    {
+        if (args.Type != "console")
+        {
+            return;
+        }
+
+        var handleArgs = args.Arguments?.Select(arg => (IJSHandle)CreateHandle(arg)).ToArray() ?? [];
+
+        var logEntryText = args.Text;
+        var text = string.Join(
+            " ",
+            handleArgs.Select(arg =>
+            {
+                if (arg is BidiJSHandle { IsPrimitiveValue: true } jsHandle)
+                {
+                    return BidiDeserializer.Deserialize(jsHandle.RemoteValue);
+                }
+
+                if (arg is BidiJSHandle { RemoteValue.Type: RemoteValueType.Error } && !string.IsNullOrEmpty(logEntryText))
+                {
+                    return (object)logEntryText.Split('\n')[0];
+                }
+
+                return arg.ToString();
+            })).Trim();
+
+        var location = GetStackTraceLocation(args.StackTrace);
+        var stackTrace = GetStackTrace(args.StackTrace);
+        var consoleMessage = new ConsoleMessage(ConvertConsoleMessageLevel(args.Method), text, handleArgs, location, stackTrace);
+        _worker.OnConsole(new ConsoleEventArgs(consoleMessage));
     }
 }
 
diff --git a/lib/PuppeteerSharp/Bidi/Core/DedicatedWorkerRealm.cs b/lib/PuppeteerSharp/Bidi/Core/DedicatedWorkerRealm.cs
@@ -26,6 +26,7 @@
 using System.Collections.Concurrent;
 using System.Linq;
 using PuppeteerSharp.Helpers;
+using WebDriverBiDi.Log;
 using WebDriverBiDi.Script;
 
 namespace PuppeteerSharp.Bidi.Core;
@@ -43,6 +44,8 @@ private DedicatedWorkerRealm(BrowsingContext context, IDedicatedWorkerOwnerRealm
 
     public event EventHandler<WorkerRealmEventArgs> Worker;
 
+    public event EventHandler<EntryAddedEventArgs> Log;
+
     public override Session Session => _owners.FirstOrDefault()?.Session;
 
     public static DedicatedWorkerRealm From(BrowsingContext context, IDedicatedWorkerOwnerRealm owner, string id, string origin)
@@ -64,11 +67,17 @@ public override void Dispose()
 
     private void Initialize()
     {
-        // Listen to realm destruction
         Session.Driver.Script.OnRealmDestroyed.AddObserver(OnRealmDestroyed);
-
-        // Listen to nested worker creation
         Session.Driver.Script.OnRealmCreated.AddObserver(OnDedicatedRealmCreated);
+        Session.LogEntryAdded += OnLogEntryAdded;
+    }
+
+    private void OnLogEntryAdded(object sender, EntryAddedEventArgs args)
+    {
+        if (args.Source.RealmId == Id)
+        {
+            Log?.Invoke(this, args);
+        }
     }
 
     private void OnRealmDestroyed(RealmDestroyedEventArgs args)
diff --git a/lib/PuppeteerSharp/Cdp/CdpWebWorker.cs b/lib/PuppeteerSharp/Cdp/CdpWebWorker.cs
diff --git a/lib/PuppeteerSharp/WebWorker.cs b/lib/PuppeteerSharp/WebWorker.cs
