Merge pull request #124 from nowsprinting/chore/remove_operatortype

Use sub-interfaces of IOperator instead of OperatorType

README.md

@@ -164,7 +164,7 @@ public class MyIntegrationTest
 
 `GetInteractableComponents` are extensions of `GameObject` that return interactable components.
 
-`SelectOperators` and `SelectOperatorsOfType` are extensions of `Component` that return available operators.
+`SelectOperators` and `SelectOperators<T>` are extensions of `Component` that return available operators.
 Operators implements `IOperator` interface. It has `OperateAsync` method that operates on the component.
 
 Usage:
@@ -183,7 +183,7 @@ public class MyIntegrationTest
         var button = await finder.FindByNameAsync("StartButton", interactable: true);
 
         var buttonComponent = button.GetInteractableComponents().First();
-        var clickOperator = buttonComponent.SelectOperatorsOfType(_operators, OperatorType.Click).First();
+        var clickOperator = buttonComponent.SelectOperators<IClickOperator>(_operators).First();
         clickOperator.OperateAsync(buttonComponent);
     }
 }
@@ -210,7 +210,7 @@ public class MyIntegrationTest
         var components = InteractiveComponentCollector.FindInteractableComponents();
 
         var firstComponent = components.First();
-        var clickAndHoldOperator = firstComponent.SelectOperatorsOfType(_operators, OperatorType.ClickAndHold).First();
+        var clickAndHoldOperator = firstComponent.SelectOperators<IClickAndHoldOperator>(_operators).First();
         await clickAndHoldOperator.OperateAsync(firstComponent);
     }
 }
@@ -238,7 +238,7 @@ public class MyIntegrationTest
         var components = InteractiveComponentCollector.FindReachableInteractableComponents();
 
         var firstComponent = components.First();
-        var textInputOperator = firstComponent.SelectOperatorsOfType(_operators, OperatorType.TextInput).First();
+        var textInputOperator = firstComponent.SelectOperators<ITextInputOperator>(_operators).First();
         textInputOperator.OperateAsync(firstComponent);   // input random text
     }
 }

Runtime/Extensions/ComponentExtensions.cs

@@ -19,8 +19,7 @@ public static class ComponentExtensions
         /// <param name="component"></param>
         /// <param name="operators">All available operators in autopilot/tests. Usually defined in <c>MonkeyConfig</c></param>
         /// <returns>Available operators</returns>
-        public static IEnumerable<IOperator> SelectOperators(this Component component,
-            IEnumerable<IOperator> operators)
+        public static IEnumerable<IOperator> SelectOperators(this Component component, IEnumerable<IOperator> operators)
         {
             return operators.Where(iOperator => iOperator.CanOperate(component));
         }
@@ -30,12 +29,11 @@ public static IEnumerable<IOperator> SelectOperators(this Component component,
         /// </summary>
         /// <param name="component"></param>
         /// <param name="operators">All available operators in autopilot/tests. Usually defined in <c>MonkeyConfig</c></param>
-        /// <param name="type">Operator type</param>
         /// <returns>Available operators</returns>
-        public static IEnumerable<IOperator> SelectOperatorsOfType(this Component component,
-            IEnumerable<IOperator> operators, OperatorType type)
+        public static IEnumerable<T> SelectOperators<T>(this Component component, IEnumerable<IOperator> operators)
+            where T : IOperator
         {
-            return operators.Where(iOperator => iOperator.Type == type && iOperator.CanOperate(component));
+            return operators.OfType<T>().Where(iOperator => iOperator.CanOperate(component));
         }
 
         /// <summary>

Runtime/InteractiveComponent.cs

@@ -144,25 +144,24 @@ public IEnumerable<IOperator> GetOperators()
         /// <summary>
         /// Returns the operators that specify types and are available to this component.
         /// </summary>
-        /// <param name="type">Operator type</param>
         /// <returns>Available operators</returns>
-        [Obsolete("Use ComponentExtensions.SelectOperatorsOfType() instead.")]
-        public IEnumerable<IOperator> GetOperatorsByType(OperatorType type)
+        [Obsolete("Use ComponentExtensions.SelectOperators<T>() instead.")]
+        public IEnumerable<T> GetOperatorsByType<T>() where T : IOperator
         {
-            return component.SelectOperatorsOfType(_operators, type);
+            return component.SelectOperators<T>(_operators);
         }
 
         /// <summary>
         /// Check component can receive click (tap) event.
         /// </summary>
         [Obsolete]
-        public bool CanClick() => GetOperatorsByType(OperatorType.Click).Any();
+        public bool CanClick() => GetOperatorsByType<IClickOperator>().Any();
 
         /// <summary>
         /// Click component.
         /// </summary>
         [Obsolete]
-        public void Click() => GetOperatorsByType(OperatorType.Click).First().OperateAsync(component);
+        public void Click() => GetOperatorsByType<IClickOperator>().First().OperateAsync(component);
 
         [Obsolete]
         public bool CanTap() => CanClick();
@@ -174,15 +173,15 @@ public IEnumerable<IOperator> GetOperatorsByType(OperatorType type)
         /// Check component can receive click (tap) and hold event.
         /// </summary>
         [Obsolete]
-        public bool CanClickAndHold() => GetOperatorsByType(OperatorType.ClickAndHold).Any();
+        public bool CanClickAndHold() => GetOperatorsByType<IClickAndHoldOperator>().Any();
 
         /// <summary>
         /// Click (touch) and hold component.
         /// </summary>
         [Obsolete]
         public async UniTask ClickAndHold(CancellationToken cancellationToken = default)
         {
-            var clickAndHoldOperator = GetOperatorsByType(OperatorType.ClickAndHold).First();
+            var clickAndHoldOperator = GetOperatorsByType<IClickAndHoldOperator>().First();
             await clickAndHoldOperator.OperateAsync(component, cancellationToken);
         }
 
@@ -197,21 +196,21 @@ public async UniTask TouchAndHold(CancellationToken cancellationToken = default)
         /// Check component can input text.
         /// </summary>
         [Obsolete]
-        public bool CanTextInput() => GetOperatorsByType(OperatorType.TextInput).Any();
+        public bool CanTextInput() => GetOperatorsByType<ITextInputOperator>().Any();
 
         /// <summary>
         /// Input random text.
         /// </summary>
         [Obsolete]
-        public void TextInput() => GetOperatorsByType(OperatorType.TextInput).First().OperateAsync(component);
+        public void TextInput() => GetOperatorsByType<ITextInputOperator>().First().OperateAsync(component);
 
         /// <summary>
         /// Input specified text.
         /// </summary>
         [Obsolete]
         public void TextInput(string text)
         {
-            var textInputOperator = (ITextInputOperator)GetOperatorsByType(OperatorType.TextInput).First();
+            var textInputOperator = GetOperatorsByType<ITextInputOperator>().First();
             textInputOperator.OperateAsync(component, text);
         }
     }

Runtime/Operators/IClickAndHoldOperator.cs

@@ -0,0 +1,13 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Click and hold operator interface.
+    /// a.k.a. touch and hold, long press.
+    /// </summary>
+    public interface IClickAndHoldOperator : IOperator
+    {
+    }
+}

Runtime/Operators/IClickOperator.cs

@@ -0,0 +1,12 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Click (tap) operator interface.
+    /// </summary>
+    public interface IClickOperator : IOperator
+    {
+    }
+}

Runtime/Operators/IDoubleClickOperator.cs

@@ -0,0 +1,12 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Double click (tap) operator interface.
+    /// </summary>
+    public interface IDoubleClickOperator : IOperator
+    {
+    }
+}

Runtime/Operators/IDragAndDropOperator.cs

@@ -0,0 +1,13 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Drag and drop operator interface.
+    /// </summary>
+    public interface IDragAndDropOperator : IOperator
+    {
+        // TODO: specify drop destination overloads
+    }
+}

Runtime/Operators/IFlickOperator.cs

@@ -0,0 +1,13 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Flick operator interface.
+    /// </summary>
+    public interface IFlickOperator : IOperator
+    {
+        // TODO: specify flick direction overloads
+    }
+}

Runtime/Operators/IHoverOperator.cs

@@ -0,0 +1,12 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Hover mouse cursor operator interface.
+    /// </summary>
+    public interface IHoverOperator : IOperator
+    {
+    }
+}

Runtime/Operators/IOperator.cs

@@ -9,19 +9,14 @@ namespace TestHelper.Monkey.Operators
 {
     /// <summary>
     /// Matcher and Operator pair for monkey testing.
-    /// Implement the <c>IsMatch</c> method to determine whether an operation such as click is possible, and the <c>Operate</c> method to execute the operation.
+    /// Implement the <c>CanOperate</c> method to determine whether an operation such as click is possible, and the <c>OperateAsync</c> method to execute the operation.
     /// </summary>
     /// <remarks>
+    /// Must be implements sub-interface (e.g., <c>IClickOperator</c>) to represent the type of operator.
     /// If required parameters for the operation, such as hold time, input text strategy, etc., keep them in instance fields of the implementation class.
     /// </remarks>
     public interface IOperator
     {
-        /// <summary>
-        /// Returns operator type.
-        /// Intended for use in capture and playback features.
-        /// </summary>
-        OperatorType Type { get; }
-
         /// <summary>
         /// Returns if can operate target component this Operator.
         /// </summary>

Runtime/Operators/IPinchOperator.cs

@@ -0,0 +1,13 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Pinch operator interface.
+    /// </summary>
+    public interface IPinchOperator : IOperator
+    {
+        // TODO: specify pinch destination and distance overloads
+    }
+}

Runtime/Operators/IRightClickOperator.cs

@@ -0,0 +1,12 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Click right button of mouse operator interface.
+    /// </summary>
+    public interface IRightClickOperator : IOperator
+    {
+    }
+}

Runtime/Operators/IScrollWheelOperator.cs

@@ -0,0 +1,14 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Scroll wheel of mouse operator interface.
+    /// scrolling up/down and tilting left/right.
+    /// </summary>
+    public interface IScrollWheelOperator : IOperator
+    {
+        // TODO: specify scroll destination and distance overloads
+    }
+}

Runtime/Operators/ISwipeOperator.cs

@@ -0,0 +1,13 @@
+// Copyright (c) 2023-2024 Koji Hasegawa.
+// This software is released under the MIT License.
+
+namespace TestHelper.Monkey.Operators
+{
+    /// <summary>
+    /// Swipe operator interface.
+    /// </summary>
+    public interface ISwipeOperator : IOperator
+    {
+        // TODO: specify swipe destination overloads
+    }
+}

Runtime/Operators/UGUIClickAndHoldOperator.cs

@@ -15,7 +15,7 @@ namespace TestHelper.Monkey.Operators
     /// Click and hold operator for Unity UI (uGUI) components.
     /// a.k.a. touch and hold, long press.
     /// </summary>
-    public class UGUIClickAndHoldOperator : IOperator
+    public class UGUIClickAndHoldOperator : IClickAndHoldOperator
     {
         private readonly int _holdMillis;
         private readonly Func<GameObject, Vector2> _getScreenPoint;
@@ -32,9 +32,6 @@ public UGUIClickAndHoldOperator(int holdMillis = 1000, Func<GameObject, Vector2>
             this._getScreenPoint = getScreenPoint ?? DefaultScreenPointStrategy.GetScreenPoint;
         }
 
-        /// <inheritdoc />
-        public OperatorType Type => OperatorType.ClickAndHold;
-
         /// <inheritdoc />
         public bool CanOperate(Component component)
         {