Update description action resolver

ferpasri · ferpasri · commit 8de9a867d975 · 2026-05-07T19:40:05.000+02:00
diff --git a/android/test/org/testar/android/action/AndroidTypeActionResolutionTest.java b/android/test/org/testar/android/action/AndroidTypeActionResolutionTest.java
@@ -0,0 +1,51 @@
+/*
+ * SPDX-License-Identifier: BSD-3-Clause
+ * Copyright (c) 2026 Universitat Politecnica de Valencia - www.upv.es
+ * Copyright (c) 2026 Open Universiteit - www.ou.nl
+ */
+
+package org.testar.android.action;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.junit.Assert;
+import org.junit.Test;
+import org.testar.android.tag.AndroidTags;
+import org.testar.core.action.Action;
+import org.testar.core.action.resolver.ResolvedAction;
+import org.testar.core.alayer.Rect;
+import org.testar.core.tag.Tags;
+import org.testar.engine.action.resolver.DescriptionActionResolver;
+import org.testar.stub.StateStub;
+import org.testar.stub.WidgetStub;
+
+public class AndroidTypeActionResolutionTest {
+
+    @Test
+    public void testResolvedAndroidTypeActionPreservesIdentityTags() {
+        StateStub state = new StateStub();
+        WidgetStub widget = new WidgetStub();
+        state.addChild(widget);
+        widget.setParent(state);
+        widget.set(Tags.Shape, Rect.fromCoordinates(0, 0, 100, 100));
+        widget.set(AndroidTags.AndroidHint, "Enter your username");
+        widget.set(AndroidTags.AndroidClassName, "android.widget.EditText");
+        widget.set(AndroidTags.AndroidXpath, "/hierarchy/android.widget.EditText");
+
+        Action templateAction = new AndroidActionType(state, widget, "RandomInput");
+        templateAction.set(Tags.AbstractID, "AAtype123");
+        templateAction.set(Tags.ConcreteID, "CCtype123");
+
+        DescriptionActionResolver resolver = new DescriptionActionResolver();
+        ResolvedAction resolvedAction = resolver.resolve(
+                Collections.singleton(templateAction),
+                List.of("type", "Enter your username", "testar")
+        );
+
+        Assert.assertTrue(resolvedAction.action() instanceof AndroidActionType);
+        Assert.assertEquals("AAtype123", resolvedAction.action().get(Tags.AbstractID, ""));
+        Assert.assertEquals("CCtype123", resolvedAction.action().get(Tags.ConcreteID, ""));
+        Assert.assertEquals("testar", resolvedAction.action().get(Tags.InputText, ""));
+    }
+}
diff --git a/engine/src/org/testar/engine/action/resolver/DescriptionActionResolver.java b/engine/src/org/testar/engine/action/resolver/DescriptionActionResolver.java
@@ -11,13 +11,15 @@
 import java.util.List;
 import java.util.Locale;
 import java.util.Optional;
+import java.util.function.Predicate;
 
 import org.testar.core.action.Action;
 import org.testar.core.action.ActionRoles;
 import org.testar.core.action.AnnotatingActionCompiler;
 import org.testar.core.action.resolver.ActionResolver;
 import org.testar.core.action.resolver.ResolvedAction;
 import org.testar.core.alayer.Role;
+import org.testar.core.state.State;
 import org.testar.core.state.Widget;
 import org.testar.core.tag.Tags;
 
@@ -30,46 +32,46 @@ public final class DescriptionActionResolver implements ActionResolver {
     @Override
     public ResolvedAction resolve(Iterable<Action> actions, List<String> arguments) {
         List<Action> orderedActions = orderedActions(actions);
+        String mode = normalizedMode(arguments);
+        String semanticText = requiredSemanticText(arguments, mode);
+
+        switch (mode) {
+            case "click":
+                return new ResolvedAction(resolveClickAction(orderedActions, semanticText));
+            case "type":
+                return new ResolvedAction(resolveTypeAction(orderedActions, semanticText, requiredInput(arguments, mode)));
+            case "select":
+                return new ResolvedAction(resolveSelectAction(orderedActions, semanticText, requiredInput(arguments, mode)));
+            default:
+                throw new IllegalArgumentException("Unsupported executeAction mode: " + mode);
+        }
+    }
+
+    private String normalizedMode(List<String> arguments) {
         String selector = argumentAt(arguments, 0);
         if (selector == null) {
             throw new IllegalArgumentException("executeAction requires an action selector");
         }
+        return selector.toLowerCase(Locale.ROOT);
+    }
 
-        String mode = selector.toLowerCase(Locale.ROOT);
+    private String requiredSemanticText(List<String> arguments, String mode) {
         String semanticText = argumentAt(arguments, 1);
         if (semanticText == null || semanticText.isBlank()) {
             throw new IllegalArgumentException("executeAction " + mode + " requires semantic text");
         }
+        return semanticText;
+    }
 
-        switch (mode) {
-            case "click":
-                return findSemanticAction(orderedActions, semanticText, false, false)
-                        .orElseThrow(() -> new IllegalArgumentException(
-                                "no click action matched semantic text: " + semanticText
-                        ));
-            case "type":
-                String inputText = joinArguments(arguments, 2);
-                if (inputText == null || inputText.isBlank()) {
-                    throw new IllegalArgumentException("executeAction type requires input text");
-                }
-                ResolvedAction matchedAction = findSemanticAction(orderedActions, semanticText, true, false)
-                        .orElseThrow(() -> new IllegalArgumentException(
-                                "no type action matched semantic text: " + semanticText
-                        ));
-                return new ResolvedAction(buildTypedAction(matchedAction.action(), inputText));
-            case "select":
-                String selectedValue = joinArguments(arguments, 2);
-                if (selectedValue == null || selectedValue.isBlank()) {
-                    throw new IllegalArgumentException("executeAction select requires a value");
-                }
-                ResolvedAction matchedSelectAction = findSemanticAction(orderedActions, semanticText, false, true)
-                        .orElseThrow(() -> new IllegalArgumentException(
-                                "no select action matched semantic text: " + semanticText
-                        ));
-                return new ResolvedAction(buildSelectAction(matchedSelectAction.action(), selectedValue));
-            default:
-                throw new IllegalArgumentException("Unsupported executeAction mode: " + selector);
+    private String requiredInput(List<String> arguments, String mode) {
+        String input = joinArguments(arguments, 2);
+        if (input == null || input.isBlank()) {
+            if ("type".equals(mode)) {
+                throw new IllegalArgumentException("executeAction type requires input text");
+            }
+            throw new IllegalArgumentException("executeAction " + mode + " requires a value");
         }
+        return input;
     }
 
     private List<Action> orderedActions(Iterable<Action> actions) {
@@ -81,27 +83,69 @@ private List<Action> orderedActions(Iterable<Action> actions) {
         return orderedActions;
     }
 
-    private Optional<ResolvedAction> findSemanticAction(List<Action> orderedActions,
-                                                        String semanticText,
-                                                        boolean typeAction,
-                                                        boolean selectAction) {
+    private Action resolveClickAction(List<Action> orderedActions, String semanticText) {
+        return findRequiredAction(
+                orderedActions,
+                semanticText,
+                this::isClickAction,
+                "no click action matched semantic text: " + semanticText
+        );
+    }
+
+    private Action resolveTypeAction(List<Action> orderedActions, String semanticText, String inputText) {
+        Action templateAction = findRequiredAction(
+                orderedActions,
+                semanticText,
+                this::isTypeAction,
+                "no type action matched semantic text: " + semanticText
+        );
+        return buildTypedAction(templateAction, inputText);
+    }
+
+    private Action resolveSelectAction(List<Action> orderedActions, String semanticText, String selectedValue) {
+        Action templateAction = findRequiredAction(
+                orderedActions,
+                semanticText,
+                this::isSelectAction,
+                "no select action matched semantic text: " + semanticText
+        );
+        return buildSelectAction(templateAction, selectedValue);
+    }
+
+    private Action findRequiredAction(List<Action> orderedActions,
+                                      String semanticText,
+                                      Predicate<Action> actionFilter,
+                                      String errorMessage) {
+        return findSemanticAction(orderedActions, semanticText, actionFilter)
+                .orElseThrow(() -> new IllegalArgumentException(errorMessage));
+    }
+
+    private Optional<Action> findSemanticAction(List<Action> orderedActions,
+                                                String semanticText,
+                                                Predicate<Action> actionFilter) {
         String normalizedSemanticText = normalizeText(semanticText);
-        // Equals semantic
-        for (int index = 0; index < orderedActions.size(); index++) {
-            Action action = orderedActions.get(index);
-            if (matchesAction(action, typeAction, selectAction)) {
-                if (normalizeText(action.get(Tags.Desc, action.toString())).equals(normalizedSemanticText)) {
-                    return Optional.of(new ResolvedAction(action));
-                }
-            }
+        Optional<Action> exactMatch = findMatchingAction(
+                orderedActions,
+                actionFilter,
+                action -> normalizedDescription(action).equals(normalizedSemanticText)
+        );
+        if (exactMatch.isPresent()) {
+            return exactMatch;
         }
-        // Contains semantic
-        for (int index = 0; index < orderedActions.size(); index++) {
-            Action action = orderedActions.get(index);
-            if (matchesAction(action, typeAction, selectAction)) {
-                if (normalizeText(action.get(Tags.Desc, action.toString())).contains(normalizedSemanticText)) {
-                    return Optional.of(new ResolvedAction(action));
-                }
+
+        return findMatchingAction(
+                orderedActions,
+                actionFilter,
+                action -> normalizedDescription(action).contains(normalizedSemanticText)
+        );
+    }
+
+    private Optional<Action> findMatchingAction(List<Action> orderedActions,
+                                                Predicate<Action> actionFilter,
+                                                Predicate<Action> semanticMatcher) {
+        for (Action action : orderedActions) {
+            if (actionFilter.test(action) && semanticMatcher.test(action)) {
+                return Optional.of(action);
             }
         }
         return Optional.empty();
@@ -114,12 +158,20 @@ private Action buildTypedAction(Action templateAction, String inputText) {
             return templateAction;
         }
 
+        Action rebuiltPlatformAction = rebuildTypedActionWithSameClass(templateAction, originWidget, inputText);
+        if (rebuiltPlatformAction != null) {
+            return withCopiedIdentity(templateAction, rebuiltPlatformAction);
+        }
+
         Role role = templateAction.get(Tags.Role, null);
         if (role == ActionRoles.ClickTypeInto) {
             if (originWidget == null) {
                 throw new IllegalArgumentException("Matched type action does not have an origin widget");
             }
-            return new AnnotatingActionCompiler().clickTypeInto(originWidget, inputText, true);
+            return withCopiedIdentity(
+                    templateAction,
+                    new AnnotatingActionCompiler().clickTypeInto(originWidget, inputText, true)
+            );
         }
 
         throw new IllegalArgumentException(
@@ -128,32 +180,64 @@ private Action buildTypedAction(Action templateAction, String inputText) {
         );
     }
 
+    private Action rebuildTypedActionWithSameClass(Action templateAction, Widget originWidget, String inputText) {
+        if (originWidget == null) {
+            return null;
+        }
+
+        Widget rootWidget = originWidget.root();
+        if (!(rootWidget instanceof State)) {
+            return null;
+        }
+
+        try {
+            return (Action) templateAction.getClass()
+                    .getConstructor(State.class, Widget.class, String.class)
+                    .newInstance((State) rootWidget, originWidget, inputText);
+        } catch (ReflectiveOperationException exception) {
+            return null;
+        }
+    }
+
     private Action buildSelectAction(Action templateAction, String selectedValue) {
         Widget originWidget = templateAction.get(Tags.OriginWidget, null);
         if (originWidget == null) {
             throw new IllegalArgumentException("Matched select action does not have an origin widget");
         }
 
+        Action rebuiltAction = invokeStaticActionFactory(
+                "org.testar.webdriver.action.WebdriverSelectListSupport",
+                "createActionForInput",
+                new Class<?>[] { Widget.class, String.class },
+                new Object[] { originWidget, selectedValue },
+                "Matched select action cannot be rebuilt without WebDriver select support"
+        );
+        if (rebuiltAction != null) {
+            return withCopiedIdentity(templateAction, rebuiltAction);
+        }
+
+        throw new IllegalArgumentException("Matched select action cannot be rebuilt due to missing target");
+    }
+
+    private Action invokeStaticActionFactory(String className,
+                                             String methodName,
+                                             Class<?>[] parameterTypes,
+                                             Object[] arguments,
+                                             String errorMessage) {
         try {
-            Class<?> supportClass = Class.forName("org.testar.webdriver.action.WebdriverSelectListSupport");
-            Object selectAction = supportClass
-                    .getMethod("createActionForInput", Widget.class, String.class)
-                    .invoke(null, originWidget, selectedValue);
-            if (selectAction instanceof Action) {
-                Action rebuiltAction = (Action) selectAction;
-                copyIdentityTags(templateAction, rebuiltAction);
-                return rebuiltAction;
+            Object action = Class.forName(className)
+                    .getMethod(methodName, parameterTypes)
+                    .invoke(null, arguments);
+            if (action instanceof Action) {
+                return (Action) action;
             }
         } catch (ReflectiveOperationException exception) {
-            throw new IllegalArgumentException(
-                    "Matched select action cannot be rebuilt without WebDriver select support",
-                    exception
-            );
+            throw new IllegalArgumentException(errorMessage, exception);
         }
-        throw new IllegalArgumentException("Matched select action cannot be rebuilt due to missing target");
+        return null;
     }
 
-    private void copyIdentityTags(Action sourceAction, Action targetAction) {
+    private Action withCopiedIdentity(Action sourceAction, Action targetAction) {
         String abstractId = sourceAction.get(Tags.AbstractID, "");
         if (!abstractId.isBlank()) {
             targetAction.set(Tags.AbstractID, abstractId);
@@ -163,6 +247,8 @@ private void copyIdentityTags(Action sourceAction, Action targetAction) {
         if (!concreteId.isBlank()) {
             targetAction.set(Tags.ConcreteID, concreteId);
         }
+
+        return targetAction;
     }
 
     private boolean isWebdriverTypeAction(Action action) {
@@ -182,32 +268,35 @@ private void applyWebdriverInputText(Action action, String inputText) {
     }
 
     private boolean isClickAction(Action action) {
-        Role role = action.get(Tags.Role, null);
-        String roleName = role == null ? "" : role.toString().toLowerCase(Locale.ROOT);
+        String roleName = roleNameOf(action);
         return roleName.contains("click") && !roleName.contains("type");
     }
 
     private boolean isTypeAction(Action action) {
-        Role role = action.get(Tags.Role, null);
-        String roleName = role == null ? "" : role.toString().toLowerCase(Locale.ROOT);
-        return roleName.contains("type");
+        return roleNameOf(action).contains("type");
     }
 
     private boolean isSelectAction(Action action) {
+        return roleNameOf(action).contains("select");
+    }
+
+    private String roleNameOf(Action action) {
         Role role = action.get(Tags.Role, null);
-        String roleName = role == null ? "" : role.toString().toLowerCase(Locale.ROOT);
-        return roleName.contains("select");
+        return role == null ? "" : role.toString().toLowerCase(Locale.ROOT);
     }
 
-    private boolean matchesAction(Action action, boolean typeAction, boolean selectAction) {
-        if (selectAction) {
-            return isSelectAction(action);
-        }
-        return typeAction ? isTypeAction(action) : isClickAction(action);
+    private String normalizedDescription(Action action) {
+        return normalizeText(action.get(Tags.Desc, action.toString()));
     }
 
     private String normalizeText(String text) {
-        return text == null ? "" : text.toLowerCase(Locale.ROOT);
+        if (text == null) {
+            return "";
+        }
+
+        String normalized = text.toLowerCase(Locale.ROOT);
+        normalized = normalized.replaceAll("[\\?\\*\\u2022\\u2023\\u25e6\\u2043\\u2219\\u25cf\\ufffd]{2,}", " passwordmask ");
+        return normalized;
     }
 
     private String joinArguments(List<String> arguments, int startIndex) {
diff --git a/engine/test/org/testar/engine/action/resolver/DescriptionActionResolverTest.java b/engine/test/org/testar/engine/action/resolver/DescriptionActionResolverTest.java
