Implement Console Events and Page.close tests (#134)

Author: PhenX

lib/PuppeteerSharp.Tests/Page/CloseTests.cs

@@ -0,0 +1,23 @@
+using System.Threading.Tasks;
+using Xunit;
+
+namespace PuppeteerSharp.Tests.Page
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class CloseTests : PuppeteerBaseTest
+    {
+        [Fact]
+        public async Task ShouldRejectAllPromisesWhenPageIsClosed()
+        {
+            var newPage = await Browser.NewPageAsync();
+            var neverResolves = newPage.EvaluateFunctionAsync("() => new Promise(r => {})");
+            
+            // Put into a var to avoid warning
+            var t = newPage.CloseAsync();
+
+            var exception = await Assert.ThrowsAsync<TargetClosedException>(async () => await neverResolves);
+            
+            Assert.Contains("Protocol error", exception.Message);
+        }
+    }
+}

lib/PuppeteerSharp.Tests/Page/Events/ConsoleTests.cs

@@ -0,0 +1,101 @@
+using System.Linq;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Newtonsoft.Json.Linq;
+using Xunit;
+
+namespace PuppeteerSharp.Tests.Page.Events
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class ConsoleTests : PuppeteerPageBaseTest
+    {
+        [Fact]
+        public async Task ShouldWork()
+        {
+            ConsoleMessage message = null;
+
+            void EventHandler(object sender, ConsoleEventArgs e)
+            {
+                message = e.Message;
+                Page.Console -= EventHandler;
+            }
+
+            Page.Console += EventHandler;
+
+            await Page.EvaluateExpressionAsync("console.log('hello', 5, {foo: 'bar'})");
+            
+            var obj = new Dictionary<string, object> {{"foo", "bar"}};
+
+            Assert.Equal("hello 5 JSHandle@object", message.Text);
+            Assert.Equal(ConsoleType.Log, message.Type);
+
+            Assert.Equal("hello", await message.Args[0].JsonValue());
+            Assert.Equal(5, await message.Args[1].JsonValue<float>());
+            Assert.Equal(obj, await message.Args[2].JsonValue<Dictionary<string, object>>());
+            Assert.Equal("bar", (await message.Args[2].JsonValue<dynamic>()).foo.ToString());
+        }
+
+        [Fact]
+        public async Task ShouldWorkForDifferentConsoleApiCalls()
+        {
+            var messages = new List<ConsoleMessage>();
+
+            Page.Console += (sender, e) => messages.Add(e.Message);
+
+            await Page.EvaluateFunctionAsync(@"() => {
+              // A pair of time/timeEnd generates only one Console API call.
+              console.time('calling console.time');
+              console.timeEnd('calling console.time');
+              console.trace('calling console.trace');
+              console.dir('calling console.dir');
+              console.warn('calling console.warn');
+              console.error('calling console.error');
+              console.log(Promise.resolve('should not wait until resolved!'));
+            }");
+
+            Assert.Equal(new[]
+            {
+                ConsoleType.TimeEnd,
+                ConsoleType.Trace,
+                ConsoleType.Dir,
+                ConsoleType.Warning,
+                ConsoleType.Error,
+                ConsoleType.Log
+            }, messages
+                .Select(_ => _.Type)
+                .ToArray());
+
+            Assert.Contains("calling console.time", messages[0].Text);
+
+            Assert.Equal(new[]
+            {
+                "calling console.trace",
+                "calling console.dir",
+                "calling console.warn",
+                "calling console.error",
+                "JSHandle@promise"
+            }, messages
+                .Skip(1)
+                .Select(msg => msg.Text)
+                .ToArray());
+        }
+
+        [Fact]
+        public async Task ShouldNotFailForWindowObject()
+        {
+            ConsoleMessage message = null;
+
+            void EventHandler(object sender, ConsoleEventArgs e)
+            {
+                message = e.Message;
+                Page.Console -= EventHandler;
+            }
+
+            Page.Console += EventHandler;
+
+            await Page.EvaluateExpressionAsync("console.error(window)");
+
+            Assert.Equal("JSHandle@object", message.Text);
+        }
+    }
+}

lib/PuppeteerSharp/ConsoleEventArgs.cs

@@ -0,0 +1,11 @@
+using System;
+
+namespace PuppeteerSharp
+{
+    public class ConsoleEventArgs : EventArgs
+    {
+        public ConsoleMessage Message { get; }
+
+        public ConsoleEventArgs(ConsoleMessage message) => Message = message;
+    }
+}

lib/PuppeteerSharp/ConsoleMessage.cs

@@ -0,0 +1,18 @@
+using System.Collections.Generic;
+
+namespace PuppeteerSharp
+{
+    public class ConsoleMessage
+    {
+        public ConsoleType Type { get; }
+        public string Text { get; }
+        public IList<JSHandle> Args { get; }
+
+        public ConsoleMessage(ConsoleType type, string text, IList<JSHandle> args)
+        {
+            Type = type;
+            Text = text;
+            Args = args;
+        }
+    }
+}

lib/PuppeteerSharp/ConsoleType.cs

@@ -0,0 +1,24 @@
+namespace PuppeteerSharp
+{
+    public enum ConsoleType
+    {
+        Log,
+        Debug,
+        Info,
+        Error,
+        Warning,
+        Dir,
+        Dirxml,
+        Table,
+        Trace,
+        Clear,
+        StartGroup,
+        StartGroupCollapsed,
+        EndGroup,
+        Assert,
+        Profile,
+        ProfileEnd,
+        Count,
+        TimeEnd,
+    }
+}

lib/PuppeteerSharp/Dialog.cs

@@ -1,27 +1,20 @@
-using System;
-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 
 namespace PuppeteerSharp
 {
     public class Dialog
     {
         private Session _client;
+        
         public DialogType DialogType { get; set; }
         public string DefaultValue { get; set; }
         public string Message { get; set; }
-        private static readonly Dictionary<string, DialogType> _dialogTypeMap = new Dictionary<string, DialogType>
-        {
-            ["alert"] = DialogType.Alert,
-            ["prompt"] = DialogType.Prompt,
-            ["confirm"] = DialogType.Confirm,
-            ["beforeunload"] = DialogType.BeforeUnload
-        };
 
-        public Dialog(Session client, string type, string message, string defaultValue)
+        public Dialog(Session client, DialogType type, string message, string defaultValue)
         {
             _client = client;
-            DialogType = GetDialogType(type);
+            DialogType = type;
             Message = message;
             DefaultValue = defaultValue;
         }
@@ -42,15 +35,5 @@ public async Task Dismiss()
                 {"accept", false}
             });
         }
-
-        public static DialogType GetDialogType(string dialogType)
-        {
-            if (_dialogTypeMap.ContainsKey(dialogType))
-            {
-                return _dialogTypeMap[dialogType];
-            }
-
-            throw new PuppeteerException($"Unknown javascript dialog type {dialogType}");
-        }
     }
 }

lib/PuppeteerSharp/DialogType.cs

@@ -1,10 +1,14 @@
-namespace PuppeteerSharp
+using System.Runtime.Serialization;
+
+namespace PuppeteerSharp
 {
     public enum DialogType
     {
         Alert,
         Prompt,
         Confirm,
-        BeforeUnload
+        
+        [EnumMember(Value = "beforeunload")]
+        BeforeUnload,
     }
 }

lib/PuppeteerSharp/ExecutionContext.cs

@@ -24,34 +24,28 @@ public ExecutionContext(Session client, ContextPayload contextPayload, Func<dyna
         public string FrameId { get; internal set; }
         public bool IsDefault { get; internal set; }
 
-        public async Task<dynamic> EvaluateExpressionAsync(string script)
+        public async Task<object> EvaluateExpressionAsync(string script)
+            => await EvaluateExpressionAsync<object>(script);
+
+        public async Task<T> EvaluateExpressionAsync<T>(string script)
         {
             var handle = await EvaluateExpressionHandleAsync(script);
-            dynamic result = await handle.JsonValue();
+            var result = await handle.JsonValue<T>();
             await handle.Dispose();
             return result;
         }
 
-        public async Task<T> EvaluateExpressionAsync<T>(string script)
-        {
-            var result = await EvaluateExpressionAsync(script);
-            return ((JToken)result).ToObject<T>();
-        }
+        public async Task<object> EvaluateFunctionAsync(string script, params object[] args)
+            => await EvaluateFunctionAsync<object>(script, args);
 
-        public async Task<dynamic> EvaluateFunctionAsync(string script, params object[] args)
+        public async Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)
         {
             var handle = await EvaluateFunctionHandleAsync(script, args);
-            dynamic result = await handle.JsonValue();
+            var result = await handle.JsonValue<T>();
             await handle.Dispose();
             return result;
         }
 
-        public async Task<T> EvaluateFunctionAsync<T>(string script, params object[] args)
-        {
-            var result = await EvaluateFunctionAsync(script, args);
-            return ((JToken)result).ToObject<T>();
-        }
-
         internal async Task<JSHandle> EvaluateExpressionHandleAsync(string script)
         {
             if (string.IsNullOrEmpty(script))

lib/PuppeteerSharp/FrameManager.cs

@@ -104,23 +104,27 @@ private void OnExecutionContextDestroyed(int executionContextId)
             }
         }
 
-        private void OnExecutionContextCreated(ContextPayload contextPayload)
+        public JSHandle CreateJsHandle(int contextId, dynamic remoteObject)
         {
+            _contextIdToContext.TryGetValue(contextId, out var storedContext);
 
-            var context = new ExecutionContext(_client, contextPayload, (dynamic remoteObject) =>
+            if (storedContext == null)
+            {
+                Console.WriteLine($"INTERNAL ERROR: missing context with id = {contextId}");
+            }
+            
+            if (remoteObject.subtype == "node")
             {
-                _contextIdToContext.TryGetValue(contextPayload.Id, out var storedContext);
+                return new ElementHandle(storedContext, _client, remoteObject, _page);
+            }
+            
+            return new JSHandle(storedContext, _client, remoteObject);
+        }
 
-                if (storedContext == null)
-                {
-                    Console.WriteLine($"INTERNAL ERROR: missing context with id = {contextPayload.Id}");
-                }
-                if (remoteObject.subtype == "node")
-                {
-                    return new ElementHandle(storedContext, _client, remoteObject, _page);
-                }
-                return new JSHandle(storedContext, _client, remoteObject);
-            });
+        private void OnExecutionContextCreated(ContextPayload contextPayload)
+        {
+            var context = new ExecutionContext(_client, contextPayload, 
+                remoteObject => CreateJsHandle(contextPayload.Id, remoteObject));
 
             _contextIdToContext[contextPayload.Id] = context;
 

lib/PuppeteerSharp/Helper.cs

@@ -1,11 +1,12 @@
 using System;
 using System.Threading.Tasks;
+using Newtonsoft.Json;
 
 namespace PuppeteerSharp
 {
     internal class Helper
     {
-        internal static object ValueFromRemoteObject(dynamic remoteObject)
+        internal static object ValueFromRemoteObject<T>(dynamic remoteObject)
         {
             if (remoteObject.unserializableValue != null)
             {
@@ -19,7 +20,38 @@ internal static object ValueFromRemoteObject(dynamic remoteObject)
                         throw new Exception("Unsupported unserializable value: " + remoteObject.unserializableValue);
                 }
             }
-            return remoteObject.value;
+
+            if (remoteObject.value == null)
+            {
+                return null;
+            }
+
+            // https://chromedevtools.github.io/devtools-protocol/tot/Runtime#type-RemoteObject
+            string objectValue = remoteObject.value.ToString();
+            string objectType = remoteObject.type.ToString();
+            
+            switch (objectType)
+            {
+                case "object":
+                    return JsonConvert.DeserializeObject<T>(objectValue);
+                case "undefined": 
+                    return null;
+                case "number":
+                    switch (Type.GetTypeCode(typeof(T)))
+                    {
+                        case TypeCode.Int32:
+                        case TypeCode.Int64:
+                            return int.Parse(objectValue);
+                        default:
+                            return float.Parse(objectValue);
+                    }
+                case "boolean": 
+                    return bool.Parse(objectValue);
+                case "bigint": 
+                    return double.Parse(objectValue);
+                default: // string, symbol, function
+                    return objectValue;
+            }
         }
 
         internal static async Task ReleaseObject(Session client, dynamic remoteObject)