Implemented all JSHandle tests (#204)

Meir017 · kblok · commit b37ef47fce20 · 2018-05-09T18:57:56.000-03:00
diff --git a/lib/PuppeteerSharp.Tests/Frame/WaitForFunctionTests.cs b/lib/PuppeteerSharp.Tests/Frame/WaitForFunctionTests.cs
@@ -56,7 +56,7 @@ public async Task ShouldThrowNegativePollingInterval()
         [Fact]
         public async Task ShouldReturnTheSuccessValueAsAJSHandle()
         {
-            Assert.Equal(5, await (await Page.WaitForFunctionAsync("() => 5")).JsonValue<int>());
+            Assert.Equal(5, await (await Page.WaitForFunctionAsync("() => 5")).JsonValueAsync<int>());
         }
 
         [Fact]
diff --git a/lib/PuppeteerSharp.Tests/JSHandleTests/AsElementTests.cs b/lib/PuppeteerSharp.Tests/JSHandleTests/AsElementTests.cs
@@ -0,0 +1,35 @@
+﻿using System.Threading.Tasks;
+using Xunit;
+
+namespace PuppeteerSharp.Tests.JSHandleTests
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class AsElementTests : PuppeteerPageBaseTest
+    {
+        [Fact]
+        public async Task ShouldWork()
+        {
+            var aHandle = await Page.EvaluateExpressionHandleAsync("document.body");
+            var element = aHandle.AsElement();
+            Assert.NotNull(element);
+        }
+
+        [Fact]
+        public async Task ShouldReturnNullForNonElements()
+        {
+            var aHandle = await Page.EvaluateExpressionHandleAsync("2");
+            var element = aHandle.AsElement();
+            Assert.Null(element);
+        }
+
+        [Fact]
+        public async Task ShouldReturnElementHandleForTextNodes()
+        {
+            await Page.SetContentAsync("<div>ee!</div>");
+            var aHandle = await Page.EvaluateExpressionHandleAsync("document.querySelector('div').firstChild");
+            var element = aHandle.AsElement();
+            Assert.NotNull(element);
+            Assert.NotNull(await Page.EvaluateFunctionAsync("e => e.nodeType === HTMLElement.TEXT_NODE", element));
+        }
+    }
+}
diff --git a/lib/PuppeteerSharp.Tests/JSHandleTests/GetPropertiesTests.cs b/lib/PuppeteerSharp.Tests/JSHandleTests/GetPropertiesTests.cs
@@ -0,0 +1,43 @@
+﻿using System.Threading.Tasks;
+using Xunit;
+
+namespace PuppeteerSharp.Tests.JSHandleTests
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class GetPropertiesTests : PuppeteerPageBaseTest
+    {
+        [Fact]
+        public async Task ShouldWork()
+        {
+            var aHandle = await Page.EvaluateExpressionHandleAsync(@"({
+              foo: 'bar'
+            })");
+            var properties = await aHandle.GetPropertiesAsync();
+            properties.TryGetValue("foo", out var foo);
+            Assert.NotNull(foo);
+            Assert.Equal("bar", await foo.JsonValueAsync<string>());
+        }
+
+        [Fact]
+        public async Task ShouldReturnEvenNonOwnProperties()
+        {
+            var aHandle = await Page.EvaluateFunctionHandleAsync(@"() => {
+              class A {
+                constructor() {
+                  this.a = '1';
+                }
+              }
+              class B extends A {
+                constructor() {
+                  super();
+                  this.b = '2';
+                }
+              }
+              return new B();
+            }");
+            var properties = await aHandle.GetPropertiesAsync();
+            Assert.Equal("1", await properties["a"].JsonValueAsync<string>());
+            Assert.Equal("2", await properties["b"].JsonValueAsync<string>());
+        }
+    }
+}
diff --git a/lib/PuppeteerSharp.Tests/JSHandleTests/GetPropertyTests.cs b/lib/PuppeteerSharp.Tests/JSHandleTests/GetPropertyTests.cs
@@ -0,0 +1,21 @@
+﻿using System.Threading.Tasks;
+using Xunit;
+
+namespace PuppeteerSharp.Tests.JSHandleTests
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class GetPropertyTests : PuppeteerPageBaseTest
+    {
+        [Fact]
+        public async Task ShouldWork()
+        {
+            var aHandle = await Page.EvaluateExpressionHandleAsync(@"({
+              one: 1,
+              two: 2,
+              three: 3
+            })");
+            var twoHandle = await aHandle.GetPropertyAsync("two");
+            Assert.Equal(2, await twoHandle.JsonValueAsync<int>());
+        }
+    }
+}
diff --git a/lib/PuppeteerSharp.Tests/JSHandleTests/JsonValueTests.cs b/lib/PuppeteerSharp.Tests/JSHandleTests/JsonValueTests.cs
@@ -0,0 +1,35 @@
+﻿using Newtonsoft.Json.Linq;
+using System.Threading.Tasks;
+using Xunit;
+
+namespace PuppeteerSharp.Tests.JSHandleTests
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class JsonValueTests : PuppeteerPageBaseTest
+    {
+        [Fact]
+        public async Task ShouldWork()
+        {
+            var aHandle = await Page.EvaluateExpressionHandleAsync("({ foo: 'bar'})");
+            var json = await aHandle.JsonValueAsync();
+            Assert.Equal(JObject.Parse("{ foo: 'bar' }"), json);
+        }
+
+        [Fact]
+        public async Task ShouldNotWorkWithDates()
+        {
+            var dateHandle = await Page.EvaluateExpressionHandleAsync("new Date('2017-09-26T00:00:00.000Z')");
+            var json = await dateHandle.JsonValueAsync();
+            Assert.Equal(JObject.Parse("{}"), json);
+        }
+
+        [Fact]
+        public async Task ShouldThrowForCircularObjects()
+        {
+            var windowHandle = await Page.EvaluateExpressionHandleAsync("window");
+            var exception = await Assert.ThrowsAsync<MessageException>(()
+                => windowHandle.JsonValueAsync());
+            Assert.Contains("Object reference chain is too long", exception.Message);
+        }
+    }
+}
diff --git a/lib/PuppeteerSharp.Tests/JSHandleTests/ToStringTests.cs b/lib/PuppeteerSharp.Tests/JSHandleTests/ToStringTests.cs
@@ -0,0 +1,25 @@
+﻿using System.Threading.Tasks;
+using Xunit;
+
+namespace PuppeteerSharp.Tests.JSHandleTests
+{
+    [Collection("PuppeteerLoaderFixture collection")]
+    public class ToStringTests : PuppeteerPageBaseTest
+    {
+        [Fact]
+        public async Task ShouldWorkForPrimitives()
+        {
+            var numberHandle = await Page.EvaluateExpressionHandleAsync("2");
+            Assert.Equal("JSHandle:2", numberHandle.ToString());
+            var stringHandle = await Page.EvaluateExpressionHandleAsync("'a'");
+            Assert.Equal("JSHandle:a", stringHandle.ToString());
+        }
+
+        [Fact]
+        public async Task ShouldWorkForComplicatedObjects()
+        {
+            var aHandle = await Page.EvaluateExpressionHandleAsync("window");
+            Assert.Equal("JSHandle@object", aHandle.ToString());
+        }
+    }
+}
diff --git a/lib/PuppeteerSharp.Tests/Page/Events/ConsoleTests.cs b/lib/PuppeteerSharp.Tests/Page/Events/ConsoleTests.cs
@@ -29,10 +29,10 @@ void EventHandler(object sender, ConsoleEventArgs e)
             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());
+            Assert.Equal("hello", await message.Args[0].JsonValueAsync());
+            Assert.Equal(5, await message.Args[1].JsonValueAsync<float>());
+            Assert.Equal(obj, await message.Args[2].JsonValueAsync<Dictionary<string, object>>());
+            Assert.Equal("bar", (await message.Args[2].JsonValueAsync<dynamic>()).foo.ToString());
         }
 
         [Fact]
diff --git a/lib/PuppeteerSharp/ExecutionContext.cs b/lib/PuppeteerSharp/ExecutionContext.cs
@@ -117,7 +117,7 @@ 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.JsonValue<T>()
+            var result = await handle.JsonValueAsync<T>()
                 .ContinueWith(jsonTask => jsonTask.Exception != null ? default(T) : jsonTask.Result);
 
             await handle.DisposeAsync();
diff --git a/lib/PuppeteerSharp/JSHandle.cs b/lib/PuppeteerSharp/JSHandle.cs
@@ -21,11 +21,37 @@ public JSHandle(ExecutionContext context, Session client, object remoteObject)
         public bool Disposed { get; set; }
         public dynamic RemoteObject { get; internal set; }
 
-        public Task<Dictionary<string, object>> GetProperty(string propertyName)
+        /// <summary>
+        /// Fetches a single property from the referenced object
+        /// </summary>
+        /// <param name="propertyName">property to get</param>
+        /// <returns>Task of <see cref="JSHandle"/></returns>
+        public async Task<JSHandle> GetPropertyAsync(string propertyName)
         {
-            throw new System.NotImplementedException();
+            var objectHandle = await ExecutionContext.EvaluateFunctionHandleAsync(@"(object, propertyName) => {
+              const result = { __proto__: null};
+              result[propertyName] = object[propertyName];
+              return result;
+            }", this, propertyName);
+            var properties = await objectHandle.GetPropertiesAsync();
+            properties.TryGetValue(propertyName, out var result);
+            await objectHandle.DisposeAsync();
+            return result;
         }
 
+        /// <summary>
+        /// Returns a <see cref="Dictionary{TKey, TValue}"/> with property names as keys and <see cref="JSHandle"/> instances for the property values.
+        /// </summary>
+        /// <returns>Task which resolves to a <see cref="Dictionary{TKey, TValue}"/></returns>
+        /// <example>
+        /// <code>
+        /// var handle = await page.EvaluateExpressionHandle("({window, document})");
+        /// var properties = await handle.GetPropertiesAsync();
+        /// var windowHandle = properties["window"];
+        /// var documentHandle = properties["document"];
+        /// await handle.DisposeAsync();
+        /// </code>
+        /// </example>
         public async Task<Dictionary<string, JSHandle>> GetPropertiesAsync()
         {
             var response = await _client.SendAsync("Runtime.getProperties", new
@@ -43,9 +69,24 @@ public async Task<Dictionary<string, JSHandle>> GetPropertiesAsync()
             return result;
         }
 
-        public async Task<object> JsonValue() => await JsonValue<object>();
+        /// <summary>
+        /// Returns a JSON representation of the object
+        /// </summary>
+        /// <returns>Task</returns>
+        /// <remarks>
+        /// The method will return an empty JSON if the referenced object is not stringifiable. It will throw an error if the object has circular references
+        /// </remarks>
+        public async Task<object> JsonValueAsync() => await JsonValueAsync<object>();
 
-        public async Task<T> JsonValue<T>()
+        /// <summary>
+        /// Returns a JSON representation of the object
+        /// </summary>
+        /// <typeparam name="T">A strongly typed object to parse to</typeparam>
+        /// <returns>Task</returns>
+        /// <remarks>
+        /// The method will return an empty JSON if the referenced object is not stringifiable. It will throw an error if the object has circular references
+        /// </remarks>
+        public async Task<T> JsonValueAsync<T>()
         {
             if (RemoteObject.objectId != null)
             {
@@ -83,7 +124,7 @@ public override string ToString()
                 return "JSHandle@" + type;
             }
 
-            return Helper.ValueFromRemoteObject<object>(RemoteObject)?.ToString();
+            return "JSHandle:" + Helper.ValueFromRemoteObject<object>(RemoteObject)?.ToString();
         }
 
         internal object FormatArgument(ExecutionContext context)
diff --git a/lib/PuppeteerSharp/Page.cs b/lib/PuppeteerSharp/Page.cs
@@ -1217,11 +1217,14 @@ private async Task OnConsoleAPI(PageConsoleResponse message)
                 return;
             }
 
-            var handles = message.Args
+            var values = message.Args
                 .Select(_ => (JSHandle)_frameManager.CreateJsHandle(message.ExecutionContextId, _))
                 .ToList();
+            var handles = values
+                .ConvertAll(handle => handle.RemoteObject["objectId"] != null
+                ? handle.ToString() : Helper.ValueFromRemoteObject<object>(handle.RemoteObject));
 
-            var consoleMessage = new ConsoleMessage(message.Type, string.Join(" ", handles), handles);
+            var consoleMessage = new ConsoleMessage(message.Type, string.Join(" ", handles), values);
             Console?.Invoke(this, new ConsoleEventArgs(consoleMessage));
         }
 

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,7 @@ public async Task ShouldThrowNegativePollingInterval()`
`56`	`56`	`[Fact]`
`57`	`57`	`public async Task ShouldReturnTheSuccessValueAsAJSHandle()`
`58`	`58`	`{`
`59`		`- Assert.Equal(5, await (await Page.WaitForFunctionAsync("() => 5")).JsonValue<int>());`
	`59`	`+ Assert.Equal(5, await (await Page.WaitForFunctionAsync("() => 5")).JsonValueAsync<int>());`
`60`	`60`	`}`
`61`	`61`
`62`	`62`	`[Fact]`
Original file line number	Diff line number	Diff line change
`@@ -117,7 +117,7 @@ internal async Task<JSHandle> EvaluateFunctionHandleAsync(string script, params`
`117`	`117`	`private async Task<T> EvaluateAsync<T>(Task<JSHandle> handleEvaluator)`
`118`	`118`	`{`
`119`	`119`	`var handle = await handleEvaluator;`
`120`		`- var result = await handle.JsonValue<T>()`
	`120`	`+ var result = await handle.JsonValueAsync<T>()`
`121`	`121`	`.ContinueWith(jsonTask => jsonTask.Exception != null ? default(T) : jsonTask.Result);`
`122`	`122`
`123`	`123`	`await handle.DisposeAsync();`
Original file line number	Diff line number	Diff line change
`@@ -1217,11 +1217,14 @@ private async Task OnConsoleAPI(PageConsoleResponse message)`
`1217`	`1217`	`return;`
`1218`	`1218`	`}`
`1219`	`1219`
`1220`		`- var handles = message.Args`
	`1220`	`+ var values = message.Args`
`1221`	`1221`	`.Select(_ => (JSHandle)_frameManager.CreateJsHandle(message.ExecutionContextId, _))`
`1222`	`1222`	`.ToList();`
	`1223`	`+ var handles = values`
	`1224`	`+ .ConvertAll(handle => handle.RemoteObject["objectId"] != null`
	`1225`	`+ ? handle.ToString() : Helper.ValueFromRemoteObject<object>(handle.RemoteObject));`
`1223`	`1226`
`1224`		`- var consoleMessage = new ConsoleMessage(message.Type, string.Join(" ", handles), handles);`
	`1227`	`+ var consoleMessage = new ConsoleMessage(message.Type, string.Join(" ", handles), values);`
`1225`	`1228`	`Console?.Invoke(this, new ConsoleEventArgs(consoleMessage));`
`1226`	`1229`	`}`
`1227`	`1230`