Release v2.4

Common/pom.xml

@@ -5,7 +5,7 @@
     <parent>
         <groupId>com.ing</groupId>
         <artifactId>ingenious-playwright</artifactId>
-        <version>2.3.1</version>
+        <version>2.4</version>
     </parent>
     <artifactId>Common</artifactId>
     <properties>

Datalib/pom.xml

@@ -4,7 +4,7 @@
     <parent>
         <groupId>com.ing</groupId>
         <artifactId>ingenious-playwright</artifactId>
-        <version>2.3.1</version>
+        <version>2.4</version>
     </parent>
     <artifactId>ingenious-datalib</artifactId>
     <packaging>jar</packaging>

Datalib/src/main/java/com/ing/datalib/component/Project.java

@@ -11,9 +11,12 @@
 import com.ing.datalib.util.data.FileScanner;
 import com.fasterxml.jackson.core.JsonProcessingException;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.ing.datalib.or.web.WebOR.ORScope;
 import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
+import java.util.LinkedHashSet;
+import java.util.Set;
 import java.util.Objects;
 import java.util.logging.Level;
 import java.util.logging.Logger;
@@ -23,8 +26,21 @@
 import javax.swing.table.TableModel;
 
 /**
+ * Represents an automation project and acts as the central entry point for loading, managing,
+ * and persisting project data from disk.
+ * <p>
+ * A {@code Project} encapsulates the project’s filesystem location and name, and maintains the
+ * in-memory model of core assets such as scenarios (TestPlan), releases/test sets (TestLab),
+ * environment test data, project settings, and the {@link ObjectRepository}. It supports loading
+ * and reloading from disk, saving all managed components, and producing table models for UI
+ * components via {@code getTableModelFor(...)}.
+ * </p>
  *
- *
+ * <p>
+ * The class also provides refactoring utilities that propagate renames across scenarios, releases,
+ * and test data (e.g., scenario/test case renames, page/object reference updates, and test data
+ * renames), including scope-aware refactoring for Object Repository references where applicable.
+ * </p>
  */
 public class Project {
 
@@ -211,7 +227,9 @@ public Boolean rename(String newName) {
                 }
             }
             getObjectRepository().getWebOR().setName(newName);
+            getObjectRepository().getWebSharedOR().setName(newName);
             getObjectRepository().getMobileOR().setName(newName);
+            getObjectRepository().getMobileSharedOR().setName(newName);
             return true;
         }
         return false;
@@ -395,7 +413,7 @@ public void refactorTestCaseScenario(String testCaseName, String oldScenarioName
                             .ifPresent(scn -> scn.setName(newScenarioName));
                 });
     }
-
+    
     public void refactorObjectName(String pageName, String oldName, String newName) {
         for (Scenario scenario : scenarios) {
             scenario.refactorObjectName(pageName, oldName, newName);
@@ -408,12 +426,57 @@ public void refactorObjectName(String oldpageName, String oldObjName, String new
         }
     }
 
+    /**
+     * Renames an object reference on the given page for the specified OR scope across the project,
+     * by delegating to all scenarios.
+     *
+     * @param scope    OR scope to match (e.g., shared vs project)
+     * @param pageName page (screen) name containing the object reference
+     * @param oldName  existing object name to replace
+     * @param newName  new object name to apply
+     */
+    public void refactorObjectName(ORScope scope, String pageName, String oldName, String newName) {
+        for (Scenario scenario : scenarios) {
+            scenario.refactorObjectName(scope, pageName, oldName, newName);
+        }
+    }
+
     public void refactorPageName(String oldPageName, String newPageName) {
         for (Scenario scenario : scenarios) {
             scenario.refactorPageName(oldPageName, newPageName);
         }
     }
 
+    /**
+     * Refactors (renames) a page reference across the project for a given Object Repository scope.
+     * <p>
+     * In addition to delegating the rename for the raw page names, this method also renames
+     * scope-qualified page names using the convention:
+     * <ul>
+     *   <li>{@code "[Shared] " + pageName} when scope is {@code ORScope.SHARED}</li>
+     *   <li>{@code "[Project] " + pageName} otherwise</li>
+     * </ul>
+     * For each {@link Scenario}, it applies both:
+     * {@code scenario.refactorPageName(oldPageName, newPageName)} and
+     * {@code scenario.refactorPageName(oldScoped, newScoped)}.
+     * </p>
+     *
+     * @param scope       the Object Repository scope used to derive the scoped page name prefix
+     * @param oldPageName the original page name to be replaced
+     * @param newPageName the new page name to apply
+     *
+     * @implNote This method performs two refactors per scenario: one for the plain page name and one
+     *           for the derived scoped form (e.g., {@code "[Shared] Login"}).
+     */
+    public void refactorPageName(ORScope scope, String oldPageName, String newPageName) {
+        String oldScoped = scope == ORScope.SHARED ? "[Shared] " + oldPageName : "[Project] " + oldPageName;
+        String newScoped = scope == ORScope.SHARED ? "[Shared] " + newPageName : "[Project] " + newPageName;
+        for (Scenario scenario : scenarios) {
+            scenario.refactorPageName(oldPageName, newPageName);
+            scenario.refactorPageName(oldScoped, newScoped);
+        }
+    }
+
     public void refactorTestData(String oldTDName, String newTDName) {
         for (Scenario scenario : scenarios) {
             scenario.refactorTestData(oldTDName, newTDName);
@@ -434,6 +497,23 @@ public List<TestCase> getImpactedObjectTestCases(String pageName, String objectN
         return impactedTestCases;
     }
 
+    public List getImpactedObjectTestCases(ORScope scope, String pageName, String objectName) {
+        Set impacted = new LinkedHashSet<>();
+        String scopedPageName = null;
+        if (scope != null) {
+            scopedPageName = (scope == ORScope.SHARED)
+                    ? "[Shared] " + pageName
+                    : "[Project] " + pageName;
+        }
+        for (Scenario scenario : scenarios) {
+            impacted.addAll(scenario.getImpactedObjectTestCases(pageName, objectName));
+            if (scopedPageName != null) {
+                impacted.addAll(scenario.getImpactedObjectTestCases(scopedPageName, objectName));
+            }
+        }
+        return new ArrayList<>(impacted);
+    }
+
     public List<TestCase> getImpactedTestCaseTestCases(String scenarioName, String testCaseName) {
         List<TestCase> impactedTestCases = new ArrayList<>();
         for (Scenario scenario : scenarios) {
@@ -520,5 +600,4 @@ private static DataItem fromTS(TestSet ts) {
             }
         }
     }
-
-}
+}

Datalib/src/main/java/com/ing/datalib/component/Scenario.java

@@ -2,13 +2,25 @@
 package com.ing.datalib.component;
 
 import com.ing.datalib.component.utils.FileUtils;
+import com.ing.datalib.or.web.WebOR.ORScope;
 import java.io.File;
 import java.util.ArrayList;
 import java.util.List;
 
 /**
+ * Represents a scenario within a project’s TestPlan and serves as a container for related test cases.
+ * <p>
+ * A {@code Scenario} is backed by a filesystem folder under {@code <project>/TestPlan/<scenario>},
+ * automatically loads its {@link TestCase} CSV files on construction, and exposes methods for adding,
+ * removing, loading, and saving test cases.
+ * </p>
  *
- * 
+ * <p>
+ * The class also implements {@code DataModel} table-model behavior for UI consumption by presenting
+ * a scenario-level view of non-reusable test cases, and provides refactoring and impact-analysis helpers
+ * that delegate to contained test cases (e.g., object/page/test data reference updates and impacted test
+ * case discovery).
+ * </p>
  */
 public class Scenario extends DataModel {
 
@@ -279,6 +291,21 @@ public void refactorObjectName(String oldpageName, String oldObjName, String new
         }
     }
 
+    /**
+     * Renames an object reference on the given page for the specified OR scope within this scenario,
+     * by delegating to all test cases.
+     *
+     * @param scope    OR scope to match (e.g., shared vs project)
+     * @param pageName page (screen) name containing the object reference
+     * @param oldName  existing object name to replace
+     * @param newName  new object name to apply
+     */
+    public void refactorObjectName(ORScope scope, String pageName, String oldName, String newName) {
+        for (TestCase testCase : testCases) {
+            testCase.refactorObjectName(scope, pageName, oldName, newName);
+        }
+    }
+
     public void refactorPageName(String oldPageName, String newPageName) {
         for (TestCase testCase : testCases) {
             testCase.refactorPageName(oldPageName, newPageName);
@@ -350,5 +377,4 @@ public Boolean delete() {
         }
         return false;
     }
-
-}
+}

Datalib/src/main/java/com/ing/datalib/component/TestCase.java

@@ -4,6 +4,7 @@
 import com.ing.datalib.component.TestStep.HEADERS;
 import com.ing.datalib.component.utils.FileUtils;
 import com.ing.datalib.component.utils.SaveListener;
+import com.ing.datalib.or.web.WebOR.ORScope;
 import java.io.File;
 import java.io.FileWriter;
 import java.util.ArrayList;
@@ -18,8 +19,21 @@
 import org.apache.commons.csv.CSVRecord;
 
 /**
+ * Represents a test case composed of ordered {@link TestStep} entries and implements a table model
+ * suitable for direct editing in UI components.
+ * <p>
+ * A {@code TestCase} belongs to a {@link Scenario}, loads and persists its steps from/to a CSV file,
+ * and supports common editing operations such as inserting, removing, moving, replicating steps,
+ * clearing values, toggling comments/breakpoints, and bulk removal. Save state is tracked and propagated
+ * via a {@link SaveListener}.
+ * </p>
  *
- * 
+ * <p>
+ * The class also supports creating and managing reusable test cases (represented as “Execute” steps),
+ * provides utilities for refactoring references (scenario/test case reuse links, object/page names,
+ * test data and columns—including scope-aware OR references), and can report impact when a given object,
+ * reusable, or test data reference is used.
+ * </p>
  */
 public class TestCase extends DataModel {
 
@@ -557,7 +571,11 @@ public void refactorObjectName(String pageName, String oldName, String newName)
         Boolean clearOnExit = getTestSteps().isEmpty();
         loadTableModel();
         for (TestStep testStep : testSteps) {
-            if (testStep.getReference().equals(pageName) && testStep.getObject().equals(oldName)) {
+            String ref = Objects.toString(testStep.getReference(), "");
+            String obj = Objects.toString(testStep.getObject(), "");
+            String normalizedRef = normalizePageRef(ref);
+
+            if (normalizedRef.equals(pageName) && obj.equals(oldName)) {
                 testStep.setObject(newName);
             }
         }
@@ -566,22 +584,85 @@ public void refactorObjectName(String pageName, String oldName, String newName)
             getTestSteps().clear();
         }
     }
-
+    
     public void refactorObjectName(String oldpageName, String oldObjName, String newPageName, String newObjName) {
         Boolean clearOnExit = getTestSteps().isEmpty();
         loadTableModel();
+
         for (TestStep testStep : testSteps) {
-            if (testStep.getReference().equals(oldpageName) && testStep.getObject().equals(oldObjName)) {
+            String ref = normalizePageRef(Objects.toString(testStep.getReference(), ""));
+            String obj = Objects.toString(testStep.getObject(), "");
+            if (ref.equals(oldpageName) && obj.equals(oldObjName)) {
                 testStep.setObject(newObjName);
                 testStep.setReference(newPageName);
             }
         }
+
         if (clearOnExit) {
             save();
             getTestSteps().clear();
         }
     }
 
+    /**
+     * Renames an object reference on the given page within this test case, restricted to the specified OR scope.
+     * A step matches when its reference has the expected scope prefix and its normalized page name equals {@code pageName}.
+     *
+     * @param scope    OR scope to match (e.g., {@code PROJECT} or {@code SHARED})
+     * @param pageName page (screen) name (without scope prefix) to match
+     * @param oldName  existing object name to replace
+     * @param newName  new object name to apply
+     */
+    public void refactorObjectName(ORScope scope, String pageName, String oldName, String newName) {
+        Boolean clearOnExit = getTestSteps().isEmpty();
+        loadTableModel();
+        for (TestStep testStep : testSteps) {
+            String refRaw = Objects.toString(testStep.getReference(), "");
+            String obj    = Objects.toString(testStep.getObject(), "");
+            boolean scopedMatch = matchesScope(refRaw, scope) && normalizePageRef(refRaw).equals(pageName);
+            if (scopedMatch && obj.equals(oldName)) {
+                testStep.setObject(newName);
+            }
+        }
+        if (clearOnExit) {
+            save();
+            getTestSteps().clear();
+        }
+    }
+
+    /**
+     * Checks whether a reference string is explicitly scoped for the given OR scope.
+     * Returns {@code true} only when {@code ref} starts with the expected scope prefix
+     * (e.g., {@code "[Project] "} or {@code "[Shared] "}); otherwise returns {@code false}.
+     *
+     * @param ref   raw reference value (may be {@code null})
+     * @param scope scope to match against
+     * @return {@code true} if {@code ref} begins with the prefix for {@code scope}; {@code false} otherwise
+     */
+    private boolean matchesScope(String ref, ORScope scope) {
+        if (ref == null) return false;
+        ref = ref.trim();
+        if (scope == ORScope.PROJECT) return ref.startsWith("[Project] ");
+        if (scope == ORScope.SHARED)  return ref.startsWith("[Shared] ");
+        return false;
+    }
+
+    /**
+     * Normalizes a page reference by removing known scope prefixes.
+     * Trims the input and strips {@code "[Project] "} or {@code "[Shared] "} when present;
+     * otherwise returns the trimmed reference. Returns an empty string when {@code ref} is {@code null}.
+     *
+     * @param ref raw reference value (may be {@code null})
+     * @return normalized page name without scope prefix (never {@code null})
+     */
+    private String normalizePageRef(String ref) {
+        if (ref == null) return "";
+        ref = ref.trim();
+        if (ref.startsWith("[Project] ")) return ref.substring("[Project] ".length()).trim();
+        if (ref.startsWith("[Shared] "))  return ref.substring("[Shared] ".length()).trim();
+        return ref;
+    }
+
     public void refactorPageName(String oldPageName, String newPageName) {
         Boolean clearOnExit = getTestSteps().isEmpty();
         loadTableModel();
@@ -662,5 +743,4 @@ public Boolean rename(String newName) {
         }
         return false;
     }
-
-}
+}