Merge pull request #44 from AutomateThePlanet/fixes-and-refactoring

Automatic Browser Shutdown Update

Author: mei-kyoseva

bellatrix.core/src/main/java/solutions/bellatrix/core/plugins/junit/BaseTest.java

@@ -31,23 +31,10 @@
 public class BaseTest extends UsesPlugins {
     static final ThreadLocal<TestResult> CURRENT_TEST_RESULT = new ThreadLocal<>();
     static final ThreadLocal<TimeRecord> CURRENT_TEST_TIME_RECORD = ThreadLocal.withInitial(TimeRecord::new);
-    private static final ThreadLocal<Boolean> CONFIGURATION_EXECUTED = new ThreadLocal<>();
+    private static final ThreadLocal<Boolean> CONFIGURATION_EXECUTED = ThreadLocal.withInitial(() -> false);
     private static final List<String> ALREADY_EXECUTED_BEFORE_CLASSES = Collections.synchronizedList(new ArrayList<>());
     private TestInfo testInfo;
 
-    public BaseTest() {
-//        try {
-//            Field theUnsafe = Unsafe.class.getDeclaredField("theUnsafe");
-//            theUnsafe.setAccessible(true);
-//            Unsafe u = (Unsafe)theUnsafe.get(null);
-//
-//            Class<?> cls = Class.forName("jdk.internal.module.IllegalAccessLogger");
-//            Field logger = cls.getDeclaredField("logger");
-//            u.putObjectVolatile(cls, u.staticFieldOffset(logger), null);
-//        } catch (Exception ignored) {}
-        CONFIGURATION_EXECUTED.set(false);
-    }
-
     @BeforeEach
     public void beforeMethodCore(TestInfo testInfo) throws Exception {
         try {

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

@@ -0,0 +1,75 @@
+/*
+ * 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 java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.TimeUnit;
+
+@UtilityClass
+public class ShutdownManager {
+    private static final List<Runnable> instructions = new CopyOnWriteArrayList<>();
+    private static final ExecutorService executor = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors());
+
+    static {
+        Runtime.getRuntime().addShutdownHook(new Thread(ShutdownManager::runAllInstructions));
+    }
+
+    public static void register(Runnable runnable) {
+        instructions.add(runnable);
+    }
+
+    private static void runAllInstructions() {
+        if (instructions.isEmpty()) return;
+
+        try {
+            // Submit all instructions for parallel execution
+            for (var instruction : instructions) {
+                executor.submit(() -> {
+                    try {
+                        instruction.run();
+                    } catch (Exception ex) {
+                        DebugInformation.debugInfo(ex.getMessage());
+                    }
+                });
+            }
+        } finally {
+            shutdownAndAwaitTermination(executor);
+        }
+    }
+
+    private static void shutdownAndAwaitTermination(ExecutorService executor) {
+        executor.shutdown(); // Disable new tasks from being submitted
+        try {
+            // Wait a while for existing tasks to terminate
+            if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
+                executor.shutdownNow(); // Cancel currently executing tasks
+                // Wait a while for tasks to respond to being cancelled
+                if (!executor.awaitTermination(60, TimeUnit.SECONDS)) {
+                    System.err.println("Executor did not terminate.");
+                }
+            }
+        } catch (InterruptedException ie) {
+            // (Re-)Cancel if current thread also interrupted
+            executor.shutdownNow();
+            // Preserve interrupt status
+            Thread.currentThread().interrupt();
+        }
+    }
+}

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

@@ -55,6 +55,14 @@ public static <T> void register(Class<?> classKey, T instance) {
             mapHolder.get().put(classKey, instance);
     }
 
+    public static boolean containsKey(Class<?> classOf) {
+        return mapHolder.get().containsKey(classOf);
+    }
+
+    public static boolean containsValue(Object object) {
+        return mapHolder.get().containsValue(object);
+    }
+    
     public static void clear() {
         mapHolder.get().clear();
     }

bellatrix.playwright/src/main/java/solutions/bellatrix/playwright/components/shadowdom/ShadowDomService.java

@@ -106,25 +106,8 @@ private static String[] getAbsoluteCss(ShadowRoot shadowRoot, String locator) {
                     .evaluate(String.format("(el, [locator]) => (%s)(el, locator)", javaScript), new Object[] { locator }))
                     .toArray(String[]::new);
         };
-        if (Wait.retry(() -> {
-            String[] foundElements;
-            try {
-                foundElements = js.call();
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-            if (foundElements == null || foundElements.length == 0) {
-                throw new IllegalArgumentException();
-            }
-        }, Duration.ofSeconds(ConfigurationService.get(WebSettings.class).getTimeoutSettings().getElementWaitTimeout()), Duration.ofSeconds(1), false)) {
-            try {
-                return js.call();
-            } catch (Exception e) {
-                throw new RuntimeException(e);
-            }
-        } else {
-            throw new IllegalArgumentException("No elements inside the shadow DOM were found with the locator: " + locator);
-        }
+
+        return getCss(js, locator);
     }
 
     private static String[] getRelativeCss(ShadowRoot shadowRoot, String locator, String parentLocator) {
@@ -134,10 +117,14 @@ private static String[] getRelativeCss(ShadowRoot shadowRoot, String locator, St
                     .toArray(String[]::new);
         };
 
+        return getCss(js, locator);
+    }
+
+    private static String[] getCss(Callable<String[]> callable, String locator) {
         if(Wait.retry(() -> {
             String[] foundElements;
             try {
-                foundElements = js.call();
+                foundElements = callable.call();
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
@@ -146,15 +133,14 @@ private static String[] getRelativeCss(ShadowRoot shadowRoot, String locator, St
             }
         }, Duration.ofSeconds(ConfigurationService.get(WebSettings.class).getTimeoutSettings().getElementWaitTimeout()), Duration.ofSeconds(1), false)) {
             try {
-                return js.call();
+                return callable.call();
             } catch (Exception e) {
                 throw new RuntimeException(e);
             }
         } else {
             throw new IllegalArgumentException("No elements inside the shadow DOM were found with the locator: " + locator);
         }
     }
-
     private static <TComponent extends WebComponent> TComponent buildMissingShadowRootsAndCreate(Class<TComponent> clazz, ShadowRoot parentComponent, Ref<String> fullCss) {
         var component = InstanceFactory.create(clazz);