Implement Page.evaluate Feature (#94)

Author: kblok

lib/PuppeteerSharp.Tests/Page/EvaluateTests.cs

@@ -0,0 +1,125 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace PuppeteerSharp.Tests.Page
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class EvaluateTests : PuppeteerBaseTest
+    {
+        [Theory]
+        [InlineData("1 + 5;", 6)] //ShouldAcceptSemiColons
+        [InlineData("2 + 5\n// do some math!'", 7)] //ShouldAceptStringComments
+        public async Task BasicIntExressionEvaluationTest(string script, object expected)
+        {
+            using (var page = await Browser.NewPageAsync())
+            {
+                var result = await page.EvaluateExpressionAsync<int>(script);
+                Assert.Equal(expected, result);
+            }
+        }
+
+        [Theory]
+        [InlineData("() => 7 * 3", 21)] //ShouldWork
+        [InlineData("() => Promise.resolve(8 * 7)", 56)] //ShouldAwaitPromise
+        public async Task BasicIntFunctionEvaluationTest(string script, object expected)
+        {
+            using (var page = await Browser.NewPageAsync())
+            {
+                var result = await page.EvaluateFunctionAsync<int>(script);
+                Assert.Equal(expected, result);
+            }
+        }
+
+        [Fact]
+        public async Task ShouldWorkRightAfterFrameNavigated()
+        {
+            Task<int> frameEvaluation = null;
+
+            using (var page = await Browser.NewPageAsync())
+            {
+                page.FrameNavigated += (sender, e) =>
+                {
+                    frameEvaluation = e.Frame.EvaluateFunctionAsync<int>("() => 6 * 7");
+                };
+
+                await page.GoToAsync(TestConstants.EmptyPage);
+                Assert.Equal(42, await frameEvaluation);
+            }
+        }
+
+        [Fact]
+        public async Task ShouldRejectPromiseWithExeption()
+        {
+            using (var page = await Browser.NewPageAsync())
+            {
+                var exception = await Assert.ThrowsAsync<EvaluationFailedException>(() =>
+                {
+                    return page.EvaluateFunctionAsync<object>("() => not.existing.object.property");
+                });
+
+                Assert.Contains("not is not defined", exception.Message);
+            }
+        }
+
+        [Fact]
+        public async Task SouldReturnComplexObjects()
+        {
+            using (var page = await Browser.NewPageAsync())
+            {
+                dynamic obj = new
+                {
+                    foo = "bar!"
+                };
+                dynamic result = await page.EvaluateFunctionAsync("a => a", obj);
+                Assert.Equal("bar!", result.foo.ToString());
+            }
+        }
+
+        [Theory]
+        [InlineData("() => NaN", double.NaN)] //ShouldReturnNaN
+        [InlineData("() => -0", -0)] //ShouldReturnNegative0
+        [InlineData("() => Infinity", double.PositiveInfinity)] //ShouldReturnInfinity
+        [InlineData("() => -Infinity", double.NegativeInfinity)] //ShouldReturnNegativeInfinty
+        public async Task BasicEvaluationTest(string script, object expected)
+        {
+            using (var page = await Browser.NewPageAsync())
+            {
+                dynamic result = await page.EvaluateFunctionAsync(script);
+                Assert.Equal(expected, result);
+            }
+        }
+
+        [Fact]
+        public async Task ShouldAcceptNullAsOneOfMultipleParameters()
+        {
+            using (var page = await Browser.NewPageAsync())
+            {
+                bool result = await page.EvaluateFunctionAsync<bool>("(a, b) => Object.is(a, null) && Object.is(b, 'foo')", null, "foo");
+                Assert.True(result);
+            }
+        }
+
+        [Fact]
+        public async Task ShouldProperlyIgnoreUndefinedFields()
+        {
+            using (var page = await Browser.NewPageAsync())
+            {
+                var result = await page.EvaluateFunctionAsync<Dictionary<string, object>>("() => ({a: undefined})");
+                Assert.Empty(result);
+            }
+        }
+
+        [Fact]
+        public async Task ShouldProperlySerializeNullFields()
+        {
+            using (var page = await Browser.NewPageAsync())
+            {
+                var result = await page.EvaluateFunctionAsync<Dictionary<string, object>>("() => ({a: null})");
+                Assert.True(result.ContainsKey("a"));
+                Assert.Null(result["a"]);
+            }
+        }
+    }
+}

lib/PuppeteerSharp.Tests/Puppeteer/PuppeteerLaunchTests.cs

@@ -65,7 +65,7 @@ public async Task ShouldRejectAllPromisesWhenBrowserIsClosed()
                                                                             TestConstants.ChromiumRevision))
             using (var page = await browser.NewPageAsync())
             {
-                var neverResolves = page.EvaluateHandle("() => new Promise(r => {})");
+                var neverResolves = page.EvaluateFunctionHandle("() => new Promise(r => {})");
                 await browser.CloseAsync();
 
                 await neverResolves;

lib/PuppeteerSharp/ContextPayloadAuxData.cs

@@ -5,4 +5,4 @@ public struct ContextPayloadAuxData
         public string FrameId { get; set; }
         public bool IsDefault { get; set; }
     }
-}
+}

lib/PuppeteerSharp/EvaluateExceptionDetails.cs

@@ -0,0 +1,14 @@
+using Newtonsoft.Json;
+
+namespace PuppeteerSharp
+{
+    public class EvaluateExceptionDetails
+    {
+        [JsonProperty("exception")]
+        public EvaluateExceptionInfo Exception { get; internal set; }
+        [JsonProperty("text")]
+        public string Text { get; internal set; }
+        [JsonProperty("stackTrace")]
+        public EvaluateExceptionStackTrace StackTrace { get; internal set; }
+    }
+}

lib/PuppeteerSharp/EvaluateExceptionInfo.cs

@@ -0,0 +1,10 @@
+using Newtonsoft.Json;
+
+namespace PuppeteerSharp
+{
+    public class EvaluateExceptionInfo
+    {
+        [JsonProperty("description")]
+        public string Description { get; internal set; }
+    }
+}

lib/PuppeteerSharp/EvaluateExceptionStackTrace.cs

@@ -0,0 +1,11 @@
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace PuppeteerSharp
+{
+    public class EvaluateExceptionStackTrace
+    {
+        [JsonProperty("callFrames")]
+        public EvaluationExceptionCallFrame[] CallFrames { get; internal set; }
+    }
+}

lib/PuppeteerSharp/EvaluationExceptionCallFrame.cs

@@ -0,0 +1,16 @@
+using Newtonsoft.Json;
+
+namespace PuppeteerSharp
+{
+    public class EvaluationExceptionCallFrame
+    {
+        [JsonProperty("columnNumber")]
+        public int ColumnNumber { get; internal set; }
+        [JsonProperty("lineNumber")]
+        public int LineNumber { get; internal set; }
+        [JsonProperty("url")]
+        public string Url { get; internal set; }
+        [JsonProperty("functionName")]
+        public string FunctionName { get; internal set; }
+    }
+}

lib/PuppeteerSharp/EvaluationFailedException.cs

@@ -4,7 +4,7 @@
 namespace PuppeteerSharp
 {
     [Serializable]
-    internal class EvaluationFailedException : Exception
+    public class EvaluationFailedException : Exception
     {
         public EvaluationFailedException()
         {

lib/PuppeteerSharp/ExceptionInfo.cs

@@ -1,6 +1,8 @@
 using System;
 using System.Collections.Generic;
 using System.Threading.Tasks;
+using System.Linq;
+using Newtonsoft.Json.Linq;
 
 namespace PuppeteerSharp
 {
@@ -22,44 +24,89 @@ public ExecutionContext(Session client, ContextPayload contextPayload, Func<dyna
         public string FrameId { get; internal set; }
         public bool IsDefault { get; internal set; }
 
-        public async Task<dynamic> Evaluate(string pageFunction, params object[] args)
+        public async Task<dynamic> EvaluateExpressionAsync(string script)
         {
-            var handle = await EvaluateHandleAsync(pageFunction, args);
+            var handle = await EvaluateExpressionHandleAsync(script);
             dynamic result = await handle.JsonValue();
             await handle.Dispose();
             return result;
         }
 
-        internal async Task<JSHandle> EvaluateHandleAsync(Func<object> pageFunction, object[] args)
+        public async Task<T> EvaluateExpressionAsync<T>(string script)
         {
-            throw new NotImplementedException();
+            var result = await EvaluateExpressionAsync(script);
+            return ((JToken)result).ToObject<T>();
         }
 
-        internal async Task<JSHandle> EvaluateHandleAsync(string pageFunction, object[] args)
+        public async Task<dynamic> EvaluateFunctionAsync(string script, params object[] args)
         {
-            if (!string.IsNullOrEmpty(pageFunction))
+            var handle = await EvaluateFunctionHandleAsync(script, args);
+            dynamic result = await handle.JsonValue();
+            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))
             {
-                dynamic remoteObject;
+                return null;
+            }
+
+            dynamic remoteObject;
 
-                try
+            try
+            {
+                remoteObject = await _client.SendAsync("Runtime.evaluate", new Dictionary<string, object>()
                 {
-                    remoteObject = await _client.SendAsync("Runtime.evaluate", new Dictionary<string, object>()
-                    {
-                        ["expression"] = pageFunction,
-                        ["contextId"] = _contextId,
-                        ["returnByValue"] = false,
-                        ["awaitPromise"] = true
-                    });
-
-                    return ObjectHandleFactory(remoteObject.result);
-                }
-                catch (Exception ex)
+                    {"contextId", _contextId},
+                    {"expression", script},
+                    {"returnByValue", false},
+                    {"awaitPromise", true}
+                });
+
+                return ObjectHandleFactory(remoteObject.result);
+            }
+            catch (Exception ex)
+            {
+                throw new EvaluationFailedException("Evaluation Failed", ex);
+            }
+        }
+
+        internal async Task<JSHandle> EvaluateFunctionHandleAsync(string script, object[] args)
+        {
+            if (string.IsNullOrEmpty(script))
+            {
+                return null;
+            }
+
+            dynamic response = await _client.SendAsync("Runtime.callFunctionOn", new Dictionary<string, object>()
                 {
-                    throw new EvaluationFailedException("Evaluation Failed", ex);
-                }
+                    {"functionDeclaration", script },
+                    {"executionContextId", _contextId},
+                    {"arguments", FormatArguments(args)},
+                    {"returnByValue", false},
+                    {"awaitPromise", true}
+                });
+
+            if (response.exceptionDetails != null)
+            {
+                throw new EvaluationFailedException("Evaluation failed: " +
+                    Helper.GetExceptionMessage(response.exceptionDetails.ToObject<EvaluateExceptionDetails>()));
             }
 
-            return null;
+            return ObjectHandleFactory(response.result);
+        }
+
+        private object FormatArguments(object[] args)
+        {
+            return args.Select(o => new { value = o });
         }
 
         public async Task<dynamic> QueryObjects(JSHandle prototypeHandle)