Add Custom Command Function to AppService Pipe

Allows for access to VisualTree within UI Test
Uses System.Test.Json serialization to return UI object info between host/harness
Added intial basic GridSplitter tests to validate (though unsure why there's such a large variance in delta from drag... test is reporting moved the right number of requested pixels, so not sure if issue with delta vs. completed in GridSplitter itself)

Author: michael-hawker

UITests/UITests.App/App.AppService.xaml.cs

@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System;
+using System.Collections.Generic;
 using System.Threading.Tasks;
 using Microsoft.Toolkit.Mvvm.Messaging;
 using UITests.App.Pages;
@@ -65,6 +66,44 @@ private async void OnAppServiceRequestReceived(AppServiceConnection sender, AppS
 
                     await args.Request.SendResponseAsync(pageResponse ? OkResult : BadResult);
 
+                    break;
+                case "Custom":
+                    if (!TryGetValueAndLog(message, "Id", out var id) || !_customCommands.ContainsKey(id))
+                    {
+                        await args.Request.SendResponseAsync(BadResult);
+                        break;
+                    }
+
+                    Log.Comment("Received request for custom command: {0}", id);
+
+                    try
+                    {
+                        ValueSet response = await _customCommands[id].Invoke(message);
+
+                        if (response != null)
+                        {
+                            response.Add("Status", "OK");
+                        }
+                        else
+                        {
+                            await args.Request.SendResponseAsync(BadResult);
+                            break;
+                        }
+
+                        await args.Request.SendResponseAsync(response);
+                    }
+                    catch (Exception e)
+                    {
+                        ValueSet errmsg = new() { { "Status", "BAD" }, { "Exception", e.Message }, { "StackTrace", e.StackTrace } };
+                        if (e.InnerException != null)
+                        {
+                            errmsg.Add("InnerException", e.InnerException.Message);
+                            errmsg.Add("InnerExceptionStackTrace", e.InnerException.StackTrace);
+                        }
+
+                        await args.Request.SendResponseAsync(errmsg);
+                    }
+
                     break;
                 default:
                     break;
@@ -118,5 +157,12 @@ private static bool TryGetValueAndLog(ValueSet message, string key, out string v
 
             return true;
         }
+
+        private Dictionary<string, Func<ValueSet, Task<ValueSet>>> _customCommands = new();
+
+        internal void RegisterCustomCommand(string id, Func<ValueSet, Task<ValueSet>> customCommandFunction)
+        {
+            _customCommands.Add(id, customCommandFunction);
+        }
     }
-}
+}

UITests/UITests.App/App.xaml.cs

@@ -6,9 +6,11 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.Reflection;
+using UITests.App.Commands;
 using UITests.App.Pages;
 using Windows.ApplicationModel;
 using Windows.ApplicationModel.Activation;
+using Windows.System;
 using Windows.UI.Xaml;
 using Windows.UI.Xaml.Controls;
 using Windows.UI.Xaml.Navigation;

UITests/UITests.App/Commands/VisualTreeHelperCommands.cs

@@ -0,0 +1,105 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using System;
+using System.Linq;
+using System.Reflection;
+using System.Text.Json;
+using System.Text.Json.Serialization;
+using System.Threading.Tasks;
+using Microsoft.Toolkit;
+using Microsoft.Toolkit.Uwp;
+using Microsoft.Toolkit.Uwp.UI;
+using UITests.App.Pages;
+using Windows.Foundation.Collections;
+using Windows.System;
+using Windows.UI.Xaml;
+using Windows.UI.Xaml.Controls;
+
+namespace UITests.App.Commands
+{
+    public static class VisualTreeHelperCommands
+    {
+        private static DispatcherQueue Queue { get; set; }
+
+        private static JsonSerializerOptions SerializerOptions { get; } = new JsonSerializerOptions(JsonSerializerDefaults.General)
+        {
+            NumberHandling = JsonNumberHandling.AllowNamedFloatingPointLiterals,
+        };
+
+        public static void Initialize(DispatcherQueue uiThread)
+        {
+            Queue = uiThread;
+
+            (App.Current as App).RegisterCustomCommand("VisualTreeHelper.FindElementProperty", FindElementProperty);
+        }
+
+        public static async Task<ValueSet> FindElementProperty(ValueSet arguments)
+        {
+            ValueSet results = new ValueSet();
+
+            if (Queue == null)
+            {
+                Log.Error("VisualTreeHelper - Missing UI DispatcherQueue");
+                return null;
+            }
+
+            await Queue.EnqueueAsync(() =>
+            {
+                // Dispatch?
+                var content = Window.Current.Content as Frame;
+
+                if (content == null)
+                {
+                    Log.Error("VisualTreeHelper.FindElementProperty - Window has no content.");
+                    return;
+                }
+
+                if (arguments.TryGetValue("ElementName", out object value) && value is string name &&
+                    arguments.TryGetValue("Property", out object value2) && value2 is string propertyName)
+                {
+                    Log.Comment("VisualTreeHelper.FindElementProperty('{0}', '{1}')", name, propertyName);
+
+                    // 1. Find Element in Visual Tree
+                    var element = content.FindDescendant(name);
+
+                    try
+                    {
+                        Log.Comment("VisualTreeHelper.FindElementProperty - Found Element? {0}", element != null);
+
+                        var typeinfo = element.GetType().GetTypeInfo();
+
+                        Log.Comment("Element Type: {0}", typeinfo.FullName);
+
+                        var prop = element.GetType().GetTypeInfo().GetProperty(propertyName);
+
+                        if (prop == null)
+                        {
+                            Log.Error("VisualTreeHelper.FindElementProperty - Couldn't find Property named {0} on type {1}", propertyName, typeinfo.FullName);
+                            return;
+                        }
+
+                        // 2. Get the property using reflection
+                        var propValue = prop.GetValue(element);
+
+                        // 3. Serialize and return the result
+                        results.Add("Result", JsonSerializer.Serialize(propValue, SerializerOptions));
+                    }
+                    catch (Exception e)
+                    {
+                        Log.Error("Error {0}", e.Message);
+                        Log.Error("StackTrace:\n{0}", e.StackTrace);
+                    }
+                }
+            });
+
+            if (results.Count > 0)
+            {
+                return results;
+            }
+
+            return null; // Failure
+        }
+    }
+}

UITests/UITests.App/MainTestHost.xaml.cs

@@ -7,6 +7,7 @@
 using System.Threading.Tasks;
 using Microsoft.Toolkit.Mvvm.Messaging;
 using Microsoft.Toolkit.Uwp;
+using UITests.App.Commands;
 using UITests.App.Pages;
 using Windows.System;
 using Windows.UI.Xaml;
@@ -33,6 +34,9 @@ public MainTestHost()
             WeakReferenceMessenger.Default.Register<RequestPageMessage>(this);
 
             _queue = DispatcherQueue.GetForCurrentThread();
+
+            // Initialize Custom Commands for AppService
+            VisualTreeHelperCommands.Initialize(_queue);
         }
 
         public void Receive(RequestPageMessage message)

UITests/UITests.App/Properties/Default.rd.xml

@@ -21,6 +21,8 @@
       the application package. The asterisks are not wildcards.
     -->
     <Assembly Name="*Application*" Dynamic="Required All" />
+    <Namespace Name="Windows.UI.Xaml.Controls" Dynamic="Required All" />
+    <Namespace Name="Microsoft.UI.Xaml.Controls" Dynamic="Required All" />
     <!-- Add your application specific runtime directives here. -->
   </Application>
 </Directives>

UITests/UITests.App/UITests.App.csproj

@@ -132,6 +132,7 @@
     <Compile Include="App.AppService.xaml.cs">
       <DependentUpon>App.xaml</DependentUpon>
     </Compile>
+    <Compile Include="Commands\VisualTreeHelperCommands.cs" />
     <Compile Include="HomePage.xaml.cs">
       <DependentUpon>HomePage.xaml</DependentUpon>
     </Compile>
@@ -178,6 +179,9 @@
     <PackageReference Include="MUXAppTestHelpers">
       <Version>0.0.4</Version>
     </PackageReference>
+    <PackageReference Include="System.Text.Json">
+      <Version>5.0.2</Version>
+    </PackageReference>
   </ItemGroup>
   <ItemGroup>
     <None Include="UITests.App.pfx" />
@@ -248,6 +252,7 @@
       <Name>Microsoft.Toolkit</Name>
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup />
   <PropertyGroup Condition=" '$(VisualStudioVersion)' == '' or '$(VisualStudioVersion)' &lt; '14.0' ">
     <VisualStudioVersion>14.0</VisualStudioVersion>
   </PropertyGroup>

UITests/UITests.Tests.MSTest/UITests.Tests.MSTest.csproj

@@ -30,6 +30,7 @@
     <PackageReference Include="System.Reflection.TypeExtensions" Version="4.5.1" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="16.7.1" />
     <PackageReference Include="Microsoft.Windows.Apps.Test" Version="1.0.181205002" />
+    <PackageReference Include="System.Text.Json" Version="5.0.2" />
   </ItemGroup>
 
   <Import Project="..\UITests.Tests.Shared\UITests.Tests.Shared.projitems" Label="Shared" />

UITests/UITests.Tests.Shared/Controls/GridSplitterTest.cs

@@ -0,0 +1,115 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+// See the LICENSE file in the project root for more information.
+
+using Microsoft.Windows.Apps.Test.Foundation;
+using Microsoft.Windows.Apps.Test.Foundation.Controls;
+using Windows.UI.Xaml.Tests.MUXControls.InteractionTests.Common;
+using Windows.UI.Xaml.Tests.MUXControls.InteractionTests.Infra;
+using System.Linq;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Dynamic;
+using System;
+
+#if USING_TAEF
+using WEX.Logging.Interop;
+using WEX.TestExecution;
+using WEX.TestExecution.Markup;
+#else
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+#endif
+
+namespace UITests.Tests
+{
+
+    [TestClass]
+    public class GridSplitterTest : UITestBase
+    {
+        [ClassInitialize]
+        [TestProperty("RunAs", "User")]
+        [TestProperty("Classification", "ScenarioTestSuite")]
+        [TestProperty("Platform", "Any")]
+        public static void ClassInitialize(TestContext testContext)
+        {
+            TestEnvironment.Initialize(testContext, WinUICsUWPSampleApp);
+        }
+
+        [TestMethod]
+        [TestPage("GridSplitterTestPage")]
+        public async Task TestGridSplitterDragHorizontalAsync()
+        {
+            var amount = 50;
+            var tolerance = 10;
+
+            var grid = FindElement.ByName("GridSplitterRoot");
+            var gridSplitter = FindElement.ById("GridSplitterHorizontal");
+            var box = FindElement.ByName("TopLeftBox");
+
+            Verify.IsNotNull(grid, "Can't find GridSplitterRoot");
+            Verify.IsNotNull(gridSplitter, "Can't find Horizontal GridSplitter");
+            Verify.IsNotNull(box, "Can't find box");
+
+            var width = box.BoundingRectangle.Width;
+
+            ColumnDefinition columnDefinitionStart = (await VisualTreeHelper.FindElementPropertyAsync<List<ColumnDefinition>>("GridSplitterRoot", "ColumnDefinitions"))?.FirstOrDefault();
+
+            Verify.IsNotNull(columnDefinitionStart, "Couldn't retrieve Column Definition");
+
+            // Drag to the Left
+            InputHelper.DragDistance(gridSplitter, amount, Direction.West, 1000);
+
+            Wait.ForMilliseconds(1050);
+            Wait.ForIdle();
+
+            ColumnDefinition columnDefinitionEnd = (await VisualTreeHelper.FindElementPropertyAsync<List<ColumnDefinition>>("GridSplitterRoot", "ColumnDefinitions"))?.FirstOrDefault();
+
+            Wait.ForIdle();
+
+            Verify.IsTrue(Math.Abs(columnDefinitionStart.ActualWidth - amount - columnDefinitionEnd.ActualWidth) <= tolerance, $"ColumnDefinition not in range expected {columnDefinitionStart.ActualWidth - amount} was {columnDefinitionEnd.ActualWidth}");
+
+            Verify.IsTrue(Math.Abs(width - amount - box.BoundingRectangle.Width) <= tolerance, $"Bounding box not in range expected {width - amount} was {box.BoundingRectangle.Width}.");
+        }
+
+        [TestMethod]
+        [TestPage("GridSplitterTestPage")]
+        public async Task TestGridSplitterDragHorizontalPastMinimumAsync()
+        {
+            var amount = 150;
+
+            var gridSplitter = FindElement.ById("GridSplitterHorizontal");
+
+            Verify.IsNotNull(gridSplitter, "Can't find Horizontal GridSplitter");
+
+            // Drag to the Left
+            InputHelper.DragDistance(gridSplitter, amount, Direction.West, 1000);
+
+            Wait.ForMilliseconds(1050);
+            Wait.ForIdle();
+
+            ColumnDefinition columnDefinitionEnd = (await VisualTreeHelper.FindElementPropertyAsync<List<ColumnDefinition>>("GridSplitterRoot", "ColumnDefinitions"))?.FirstOrDefault();
+
+            Wait.ForIdle();
+
+            Verify.AreEqual(columnDefinitionEnd.MinWidth, columnDefinitionEnd.ActualWidth, "Column was not the minimum size expected.");
+        }
+
+        private class ColumnDefinition
+        {
+            public GridLength Width { get; set; }
+
+            public double ActualWidth { get; set; }
+
+            public double MinWidth { get; set; }
+
+            public double MaxWidth { get; set; }
+        }
+
+        private class GridLength
+        {
+            public int GridUnitType { get; set; } // 0 Auto, 1 Pixel, 2 Star
+
+            public double Value { get; set; }
+        }
+    }
+}