Merge pull request #38 from AutomateThePlanet/bellatrix-shadow-dom-upgrade

Bellatrix Shadow DOM Upgrade

Author: mei-kyoseva

bellatrix.core/pom.xml

@@ -153,5 +153,20 @@
             <version>${rest.assured.version}</version>
             <scope>compile</scope>
         </dependency>
+        <dependency>
+            <groupId>com.azure</groupId>
+            <artifactId>azure-security-keyvault-secrets</artifactId>
+            <version>4.2.3</version>
+        </dependency>
+        <dependency>
+            <groupId>com.azure</groupId>
+            <artifactId>azure-identity</artifactId>
+            <version>1.2.0</version>
+        </dependency>
+        <dependency>
+            <groupId>org.jsoup</groupId>
+            <artifactId>jsoup</artifactId>
+            <version>1.17.2</version>
+        </dependency>
     </dependencies>
 </project>

bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/ConverterService.java

@@ -1,14 +1,33 @@
+/*
+ * Copyright 2024 Automate The Planet Ltd.
+ * Author: Miriam Kyoseva
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
 package solutions.bellatrix.core.utilities;
 
 import lombok.SneakyThrows;
 
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.List;
+
 public class ConverterService {
     public static <SourceT, ResultT> ResultT convert(SourceT source, int index) {
         ResultT object = InstanceFactory.createByTypeParameter(source.getClass(), index);
 
+        assert object != null;
         return convert(source, object);
     }
 
+    @SuppressWarnings("unchecked")
     public static <SourceT, ResultT> ResultT convert(SourceT source, ResultT result) {
         var object = (ResultT) InstanceFactory.create(result.getClass());
 
@@ -38,8 +57,8 @@ public static <SourceT, ResultT> ResultT convert(SourceT source, ResultT result)
     public static <SourceT, ResultT> ResultT convertToClass(SourceT source, Class<ResultT> result) {
         var object = (ResultT) InstanceFactory.create(result);
 
-        var sourceFields = source.getClass().getDeclaredFields();
-        var objectFields = object.getClass().getDeclaredFields();
+        List<Field> sourceFields = getAllFields(source.getClass());
+        List<Field> objectFields = getAllFields(object.getClass());
 
         for (var sourceField : sourceFields) {
             for (var objectField : objectFields) {
@@ -55,4 +74,19 @@ public static <SourceT, ResultT> ResultT convertToClass(SourceT source, Class<Re
 
         return object;
     }
+
+    private static List<Field> getAllFields(Class<?> clazz) {
+        List<Field> fields = new ArrayList<>();
+        Class<?> currentClass = clazz;
+
+        while (currentClass != null) {
+            var declaredFields = currentClass.getDeclaredFields();
+            for (Field field : declaredFields) {
+                fields.add(field);
+            }
+            currentClass = currentClass.getSuperclass();
+        }
+
+        return fields;
+    }
 }

bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/HtmlService.java

@@ -0,0 +1,128 @@
+/*
+ * Copyright 2024 Automate The Planet Ltd.
+ * Author: Miriam Kyoseva
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * You may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package solutions.bellatrix.core.utilities;
+
+import lombok.experimental.UtilityClass;
+import org.jsoup.nodes.Document;
+import org.jsoup.nodes.Element;
+import org.jsoup.nodes.Node;
+import solutions.bellatrix.core.utilities.parsing.TypeParser;
+
+import java.util.Arrays;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+/**
+ * Web Utility Class
+ */
+@UtilityClass
+public class HtmlService {
+    private static final String CHILD_COMBINATOR = " > ";
+    private static final String NODE = "/";
+    private static final String NODE_OR_SELF = "//";
+    private static final String ROOT_ELEMENT_TAG = "bellatrix-root";
+
+    public static Document addRootElementIfNeeded(Document doc) {
+        boolean hasMultipleTopLevelElements = doc.childNodes().stream()
+                .filter(node -> node instanceof Element).count() > 1;
+
+        if (hasMultipleTopLevelElements) {
+            var root = new Element(ROOT_ELEMENT_TAG);
+
+            for (Node node : doc.childNodes()) {
+                root.appendChild(node.clone());
+            }
+
+            doc.empty();
+            doc.appendChild(root);
+        }
+
+        return doc;
+    }
+
+    public static String getAbsoluteXpath(Element element) {
+        StringBuilder xpath = new StringBuilder();
+
+        Element currentElement = element;
+        while (currentElement != null) {
+            if (currentElement.tagName().equals("html") || currentElement.tagName().equals("body") || currentElement.tagName().startsWith("#") || currentElement.tagName().equals(ROOT_ELEMENT_TAG)) {
+                // ignore the <html> and <body>, because jsoup added them to the html fragment
+                // ignore added bellatrix root element
+                // ignore invalid element tags
+                break;
+            }
+
+            xpath.insert(0, indexElement(currentElement));
+
+            currentElement = currentElement.parent();
+        }
+
+        return xpath.toString();
+    }
+
+    private String indexElement(Element element) {
+        int index = 1;
+
+        Node previousSibling = element.previousSibling();
+        while (previousSibling != null) {
+            if (previousSibling.nodeName().equals(element.nodeName())) {
+                index++;
+            }
+            previousSibling = previousSibling.previousSibling();
+        }
+
+        return NODE + element.tagName() + "[" + index + "]";
+    }
+
+    public <T> T getAttribute(Element element, String attributeName, Class<T> clazz) {
+        if (element.attribute(attributeName) == null || element.attribute(attributeName).getValue() == null || element.attribute(attributeName).getValue().isBlank()) {
+            return null;
+        } else {
+            return TypeParser.parse(element.attribute(attributeName).getValue(), clazz);
+        }
+    }
+
+    public static String convertAbsoluteXpathToCss(String xpath) {
+        String cssSelector = xpath.replace(NODE, CHILD_COMBINATOR);
+
+        // Use regular expression to replace [number] with :nth-of-type(number)
+        Pattern pattern = Pattern.compile("\\[(\\d+)\\]");
+        Matcher matcher = pattern.matcher(cssSelector);
+        StringBuilder builder = new StringBuilder();
+
+        while (matcher.find()) {
+            matcher.appendReplacement(builder, ":nth-of-type(" + matcher.group(1) + ")");
+        }
+        matcher.appendTail(builder);
+
+        var semiFinalLocator = builder.toString();
+
+        if (semiFinalLocator.startsWith(CHILD_COMBINATOR)) {
+            semiFinalLocator = semiFinalLocator.substring(2);
+        }
+
+        return semiFinalLocator;
+    }
+
+    public static String removeDanglingChildCombinatorsFromCss(String css) {
+        // convert to array by splitting the css by the child combinator
+        // and remove from that array empty steps
+        var steps = Arrays.stream(css.split(CHILD_COMBINATOR))
+                .filter(x -> !x.isBlank())
+                .toArray(String[]::new);
+
+        // join the remaining steps with child combinator operators
+        return String.join(CHILD_COMBINATOR, steps);
+    }
+}

bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/InstanceFactory.java

@@ -16,6 +16,7 @@
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.ParameterizedType;
 
+@SuppressWarnings("unchecked")
 public final class InstanceFactory {
     public static <T> T create(Class<T> classOf) {
         T obj = null;

bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/PropertyReference.java

@@ -0,0 +1,8 @@
+package solutions.bellatrix.core.utilities;
+
+import java.io.Serializable;
+
+@FunctionalInterface
+public interface PropertyReference<T> extends Serializable {
+    Object apply(T t);
+}

bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/PropertyReferenceNameResolver.java

@@ -0,0 +1,33 @@
+package solutions.bellatrix.core.utilities;
+
+import lombok.SneakyThrows;
+import lombok.experimental.UtilityClass;
+
+import java.lang.invoke.SerializedLambda;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+
+@UtilityClass
+public class PropertyReferenceNameResolver {
+    public static <T> Field getMember(Class<T> clazz, PropertyReference<T> propertyReference) {
+        var methodName = getFunctionalMethodName(propertyReference);
+        var fields = clazz.getDeclaredFields();
+
+        for (var field : fields) {
+            if (methodName.toLowerCase().contains(field.getName().toLowerCase())) {
+                return field;
+            }
+        }
+
+        return null;
+    }
+
+    @SneakyThrows
+    public static String getFunctionalMethodName(PropertyReference<?> functionalInterface) {
+        Method writeReplaceMethod = functionalInterface.getClass().getDeclaredMethod("writeReplace");
+        writeReplaceMethod.setAccessible(true);
+        SerializedLambda serializedLambda = (SerializedLambda) writeReplaceMethod.invoke(functionalInterface);
+
+        return serializedLambda.getImplMethodName();
+    }
+}

bellatrix.playwright/src/main/java/solutions/bellatrix/playwright/utilities/functionalinterfaces/AssertionMethod.java renamed to bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/Ref.java

@@ -11,9 +11,15 @@
  * limitations under the License.
  */
 
-package solutions.bellatrix.playwright.utilities.functionalinterfaces;
+package solutions.bellatrix.core.utilities;
 
-@FunctionalInterface
-public interface AssertionMethod {
-    void perform();
-}
+/**
+ * Wrapper for passing primitives by reference.
+ */
+public class Ref<T> {
+    public T value;
+
+    public Ref(T value) {
+        this.value = value;
+    }
+}

bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/SingletonFactory.java

@@ -13,31 +13,42 @@
 
 package solutions.bellatrix.core.utilities;
 
+import lombok.SneakyThrows;
+import lombok.experimental.UtilityClass;
+
 import java.util.HashMap;
 import java.util.Map;
 
 // Based on http://neutrofoton.github.io/blog/2013/08/29/generic-singleton-pattern-in-java/
 // Can be used inside App design pattern.
+@SuppressWarnings("unchecked")
 public class SingletonFactory {
     private static final SingletonFactory SINGLETON_FACTORY = new SingletonFactory();
 
-    private final Map<String, Object> mapHolder = new HashMap<>();
+    private final Map<Class<?>, Object> mapHolder = new HashMap<>();
 
     private SingletonFactory() {
     }
 
+    @SneakyThrows
     public static <T> T getInstance(Class<T> classOf, Object... initargs) {
         try {
-            if (!SINGLETON_FACTORY.mapHolder.containsKey(classOf.getName())) {
-
+            if (!SINGLETON_FACTORY.mapHolder.containsKey(classOf)) {
                 T obj = (T)classOf.getConstructors()[0].newInstance(initargs);
-                SINGLETON_FACTORY.mapHolder.put(classOf.getName(), obj);
+                SINGLETON_FACTORY.mapHolder.put(classOf, obj);
             }
-
-            return (T)SINGLETON_FACTORY.mapHolder.get(classOf.getName());
+            return (T)SINGLETON_FACTORY.mapHolder.get(classOf);
         } catch (Exception e) {
             Log.error("Failed to create instance of the object. Exception was: " + e);
             return null;
         }
     }
+
+    public static <T> void register(T instance) {
+        SINGLETON_FACTORY.mapHolder.put(instance.getClass(), instance);
+    }
+
+    public static <T> void register(Class<?> classKey, T instance) {
+        SINGLETON_FACTORY.mapHolder.put(classKey, instance);
+    }
 }

bellatrix.core/src/main/java/solutions/bellatrix/core/utilities/Wait.java

@@ -77,4 +77,28 @@ public static boolean retry(Runnable action, Duration timeout, Duration sleepInt
     public static void retry(Runnable action, Duration timeout, Duration sleepInterval, Class<? extends Throwable> ... exceptionsToIgnore) {
         Wait.retry(action, timeout, sleepInterval, true, exceptionsToIgnore);
     }
+
+    public static boolean forConditionUntilTimeout(Comparator condition, long timeoutInMilliseconds, long pollingIntervalInMilliseconds) {
+        boolean isConditionMet = false;
+
+        long startTime = System.currentTimeMillis();
+
+        while (!isConditionMet && (System.currentTimeMillis() - startTime) <= (timeoutInMilliseconds)) {
+            try {
+                if (condition.evaluate()) {
+                    isConditionMet = true;
+                } else {
+                    Thread.sleep(pollingIntervalInMilliseconds);
+                }
+            } catch (Exception ignored) {
+            }
+        }
+
+        return isConditionMet;
+    }
+
+    @FunctionalInterface
+    public interface Comparator {
+        boolean evaluate();
+    }
 }