Throw error when page reloads during page.evaluate (#370)

Author: kblok

lib/PuppeteerSharp.Tests/PageTests/EvaluateTests.cs

@@ -81,7 +81,10 @@ public async Task BasicEvaluationTest(string script, object expected)
         [Fact]
         public async Task ShouldAcceptNullAsOneOfMultipleParameters()
         {
-            bool result = await Page.EvaluateFunctionAsync<bool>("(a, b) => Object.is(a, null) && Object.is(b, 'foo')", null, "foo");
+            var result = await Page.EvaluateFunctionAsync<bool>(
+                "(a, b) => Object.is(a, null) && Object.is(b, 'foo')",
+                null,
+                "foo");
             Assert.True(result);
         }
 
@@ -113,7 +116,7 @@ public async Task ShouldFailForWindowObjectUsingEvaluateFunction()
             var window = await Page.EvaluateFunctionAsync("() => window");
             Assert.Null(window);
         }
-        
+
         [Fact]
         public async Task ShouldAcceptElementHandleAsAnArgument()
         {
@@ -173,5 +176,34 @@ await Page.ExposeFunctionAsync("callController", async (int a, int b) =>
             }");
             Assert.Equal(27, result);
         }
+
+        [Fact]
+        public async Task ShouldThrowWhenEvaluationTriggersReload()
+        {
+            var exception = await Assert.ThrowsAsync<MessageException>(() =>
+            {
+                return Page.EvaluateFunctionAsync<object>(@"() => {
+                    location.reload();
+                    return new Promise(resolve => {
+                        setTimeout(() => resolve(1), 0);
+                    });
+                }");
+            });
+
+            Assert.Contains("Protocol error", exception.Message);
+        }
+
+        [Fact]
+        public async Task ShouldFailForCircularObject()
+        {
+            var result = await Page.EvaluateFunctionAsync<object>(@"() => {
+                const a = {};
+                const b = {a};
+                a.b = b;
+                return a;
+            }");
+
+            Assert.Null(result);
+        }
     }
 }

lib/PuppeteerSharp/ExecutionContext.cs

@@ -125,7 +125,7 @@ public async Task<dynamic> QueryObjectsAsync(JSHandle prototypeHandle)
                 throw new PuppeteerException("Prototype JSHandle must not be referencing primitive value");
             }
 
-            dynamic response = await _client.SendAsync("Runtime.queryObjects", new Dictionary<string, object>()
+            dynamic response = await _client.SendAsync("Runtime.queryObjects", new Dictionary<string, object>
             {
                 {"prototypeObjectId", objectId.ToString()}
             });
@@ -140,7 +140,7 @@ internal async Task<JSHandle> EvaluateExpressionHandleAsync(string script)
                 return null;
             }
 
-            return await EvaluateHandleAsync("Runtime.evaluate", new Dictionary<string, object>()
+            return await EvaluateHandleAsync("Runtime.evaluate", new Dictionary<string, object>
             {
                 {"contextId", _contextId},
                 {"expression", script},
@@ -156,7 +156,7 @@ internal async Task<JSHandle> EvaluateFunctionHandleAsync(string script, params
                 return null;
             }
 
-            return await EvaluateHandleAsync("Runtime.callFunctionOn", new Dictionary<string, object>()
+            return await EvaluateHandleAsync("Runtime.callFunctionOn", new Dictionary<string, object>
             {
                 {"functionDeclaration", script },
                 {"executionContextId", _contextId},
@@ -169,9 +169,20 @@ internal async Task<JSHandle> EvaluateFunctionHandleAsync(string script, params
         private async Task<T> EvaluateAsync<T>(Task<JSHandle> handleEvaluator)
         {
             var handle = await handleEvaluator;
-            var result = await handle.JsonValueAsync<T>()
-                .ContinueWith(jsonTask => jsonTask.Exception != null ? default(T) : jsonTask.Result);
+            var result = default(T);
 
+            try
+            {
+                result = await handle.JsonValueAsync<T>()
+                    .ContinueWith(jsonTask => jsonTask.Exception != null ? default : jsonTask.Result);
+            }
+            catch (Exception ex)
+            {
+                if (!ex.Message.Contains("Object reference chain is too long"))
+                {
+                    throw new EvaluationFailedException(ex.Message, ex);
+                }
+            }
             await handle.DisposeAsync();
             return result;
         }