Changeset 39038

Timestamp:

2024-05-21T23:19:11+12:00 (3 weeks ago)

Author:

anupama

Message:

Working with GLI's metadata table is proving very hard as the GLI code has automated its behaviour: whenever the user clicks in a metavalue cell with a value and presses enter, a dummy next cell is created. This appears to be causing all kinds of side effects to my testing code when I try to work with JTableFixture and when I try to work with GLI's behaviour as it is (I thought of pasting strings in there using the clipboard, but that doesn't work in this case).

Location:

gs3-extensions/testing/trunk/src

Files:

• README (modified) (1 diff)
• lib/java/GSTestingUtil.jar (modified) ( previous)
• src/gstests/tutorials/RunGLITest.java (modified) (3 diffs)
• src/org/greenstone/gsdl3/testing/GSGUITestingUtil.java (modified) (5 diffs)

gs3-extensions/testing/trunk/src/README

@@ -38 +38 @@
 - VERY USEFUL BASICS: https://docs.oracle.com/javase/6/docs/api/javax/swing/package-summary.html#threading
 - EDT and AssertJ Swing: https://joel-costigliola.github.io/assertj/assertj-swing-edt.html
-
+- Possibl useful: https://assertj-swing.readthedocs.io/en/latest/assertj-swing-basics/#base-test-class
 
 NOTES on moving any code into Runnable class inside Gatherer.invokeOnDispatchThread (which does SwingUtilities.invokeAndWait/invokeLater):

gs3-extensions/testing/trunk/src/src/gstests/tutorials/RunGLITest.java

@@ -327 +327 @@
              "Simple image collection");
     
-    loadCollection("backdrop");
+    //loadCollection("backdrop");
     PAUSE(3);
     */  
@@ -359 +359 @@
         
     PAUSE(3);
-    */
+    
     
     switchToPane(CREATE_PANE);
@@ -366 +366 @@
     //previewCollection();
     buildAndPreviewCollection(MAX_BUILD_TIMEOUT);
-
-    switchToPane(ENRICH_PANE);
-    PAUSE(1);
+    */
+    switchToPane(ENRICH_PANE);  
+    PAUSE(1);   
     //openCollectionPath("Bear.jpg", CLICK);
-    exitGLI(); // save popup changes
+    //changeToMetadataSet("Dublin Core Metadata Element Set");
+
+    setMeta("Bear.jpg", "dc.Title", "Bear");
+    //addMeta("Bear.jpg", "dc.Title", "Toto");
+    //addMeta("Bear.jpg", "dc.Title", "Lala");
+    
+      String[] metavalues = {"lala", "pinky", "dodo"};
+      addMetaValsToCurrentDoc("dc.Title", metavalues);
+    //setMeta("Cat.jpg", "dc.Title", "Cat");
+    //setMeta("Cheetah.jpg", "dc.Title", "Cheetah");
+    PAUSE(2);
+    //exitGLI(); // needed, to save warning popup changes
     }
     

gs3-extensions/testing/trunk/src/src/org/greenstone/gsdl3/testing/GSGUITestingUtil.java

@@ -2 +2 @@
 
 import java.io.File;
+import java.util.Collection;
+import java.util.Iterator;
 import java.util.Map;
+import java.util.AbstractMap.SimpleEntry;
+import java.util.concurrent.TimeUnit;
 import java.util.regex.*;
 import java.awt.Component;
+import java.awt.Toolkit;
 import java.awt.event.InputEvent;
 import javax.swing.*;
+import java.awt.datatransfer.*; // Clipboard, Transferable, DataFlavor;
+
 
 // only JUnit and JAssert-Swing, no Selenium in this class
@@ -12 +19 @@
 import org.assertj.swing.fixture.*;
 import org.assertj.swing.timing.Timeout;
-
+import org.assertj.swing.data.TableCell;
+    
 import org.assertj.swing.timing.Pause;
 import org.assertj.swing.timing.Condition;
-import java.util.concurrent.TimeUnit;
+import org.assertj.swing.util.Platform;
     
 // GLI imports
@@ -35 +43 @@
 //import org.assertj.swing.core.matcher.DialogMatcher; // withTitle
 //import org.assertj.swing.core.matcher.FrameMatcher; // withTitle
-
+import org.assertj.swing.core.KeyPressInfo;
 
 // static imports (allows shorthand global calls directly to the static functions imported)
@@ -46 +54 @@
 import static org.assertj.swing.finder.WindowFinder.findFrame;
 import static org.assertj.swing.finder.WindowFinder.findDialog;
-
+import static org.assertj.swing.core.KeyPressInfo.*; // declares keycodes
 
 /*
@@ -989 +997 @@
     /********************* ENRICH PANE ******************/
     // docPath can be just docName or collectionSubfolder/Subfolder2/docName
-    public static void addMeta(String docPath, Map metanamesToValues) {}
+    //public static void addMeta(String docPath, Map metanamesToValues) {}
     public static void addFolderLevelMeta(String folderPath, Map metanamesToValues) {}
 
+    public static void changeToMetadataSet(String toSet) {
+    window.button("EnrichPane.external_split.GLIButton.Manage Metadata Sets...").click();
+    //DialogFixture mdsetDialog = findDialog("MetadataSetDialog").using(robot);
+    DialogFixture mdsetDialog = window.dialog("MetadataSetDialog");
+    // Add, select toSet, Add, Close
+    mdsetDialog.button("MetadataSetDialog.add_button").click();
+    // Name of next dialog that pops up ends up being AddMetadataSetPrompt.add_set_dialog
+    DialogFixture addMetaDialog = mdsetDialog.dialog("AddMetadataSetPrompt.add_set_dialog");//window.dialog("AddMetadataSetPrompt.add_set_dialog");//findDialog(DialogMatcher.withTitle(Dictionary.get("MetadataSetDialog.Add_Title"))).using(robot);
+    JListFixture mds_list = addMetaDialog.list("AddMetadataSetPrompt.available_sets_list");
+    PAUSE(3);
+    mds_list.selectItem(Pattern.compile("^"+toSet+".*$"));
+    PAUSE(2);
+    addMetaDialog.button("AddMetadataSetPrompt.add_button").click();
+    PAUSE(1);
+    mdsetDialog.button("MetadataSetDialog.close_button").click();
+    }
+
+    public static void setMeta(String documentPath, String metaname, String metavalue) {
+    openCollectionPath(documentPath, CLICK);
+    JTableFixture metatable = window.table("MetadataValueTable");
+    JTableCellFixture cell = metatable.cell(metaname);
+    int row = cell.row();
+    int col = cell.column();
+    TableCell valueCell = TableCell.row(row).column(col+1);
+    metatable.enterValue(valueCell, metavalue);
+    System.err.println("#### Metaname column: " + col);
+    
+    }
+    /*
+    public static void addMeta(String documentPath, String metaname, String metavalue) {
+    openCollectionPath(documentPath, CLICK);
+    JTableFixture metatable = window.table("MetadataValueTable");
+    JTableCellFixture cell = metatable.cell(metaname); // First matching metaname
+    //GLI has programmed behaviour that makes this code funny:
+    //It pre positions the cursor for you to enter the Next metaname
+    // But in assertJ swing testing code we need to access cells manually.
+    // But always clicking on value cell for metaname and hitting RETURN allows
+    // adding meta in correct cell. But we can only call enterValue() on row and column
+    // of a cell we know. So we need to find the table(row,col) of the cell GLI positioned
+    // us at after we press click and RETURN and then enter the value there.
+    cell.click();
+    //PAUSE(0.5);
+    metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER);
+    PAUSE(0.5);
+
+
+    enterStringInFocusedElement(metatable, metavalue);
+    //openCollectionPath(documentPath, CLICK);
+    }
+    */
+    public static void enterStringInFocusedElement(AbstractComponentFixture widget,
+                           String theString)
+    {
+    // BAD IDEA: looping through characters and mapping them to keycodes won't work if unicode
+    // https://stackoverflow.com/questions/196830/what-is-the-easiest-best-most-correct-way-to-iterate-through-the-characters-of-a
+    // pseudocode was:
+    //for each character in metavalue
+    //   widget.pressKey(c);
+    
+
+    // Copy paste should work if I can copy to clipboard
+    // https://stackoverflow.com/questions/3591945/copying-to-the-clipboard-in-java
+    System.err.println("### Copying to clipboard: " + theString);
+    putOnClipboard(theString);
+    System.err.println("### Pasting from clipboard.");
+    pasteClipboard(widget);
+    
+    }
+
+    public static void putOnClipboard(String theString) {
+    // https://stackoverflow.com/questions/3591945/copying-to-the-clipboard-in-java
+    StringSelection selection = new StringSelection(theString);
+    Clipboard clipboard = Toolkit.getDefaultToolkit().getSystemClipboard();
+    clipboard.setContents(selection, selection);
+
+    }
+    //http://www.avajava.com/tutorials/lessons/how-do-i-get-a-string-from-the-clipboard.html
+    public static String getStringFromClipboard() {
+    String result = "Clipboard retrieval failed";
+    try {
+        Toolkit toolkit = Toolkit.getDefaultToolkit();
+        Clipboard clipboard = toolkit.getSystemClipboard();
+        result = (String) clipboard.getData(DataFlavor.stringFlavor);
+    } catch(Exception e) {
+        System.err.println("Failed to retrieve from clipboard. Exception: " + e.getMessage());
+    }
+    return result;
+    }
+    public static void pasteClipboard(AbstractComponentFixture widget) {
+    //https://joel-costigliola.github.io/assertj/swing/api/org/assertj/swing/core/KeyPressInfo.html
+    //  Specify that 'SHIFT' + 'R' should be pressed:
+    // // import static org.assertj.swing.fixture.KeyPressInfo.*;
+    // KeyPressInfo i = key(VK_R).modifiers(SHIFT_MASK);
+    // For platform-safe mask pressing (e.g. 'Control' in Windows or 'Command' in MacOS) use Platform.controlOrCommandMask().
+
+    // press Ctrl/Command+V on widget
+    // TODO:
+    //KeyPressInfo kpi = keyCode(java.awt.event.KeyEvent.VK_V).modifiers(Platform.controlOrCommandMask());
+    KeyPressInfo kpi = keyCode(java.awt.event.KeyEvent.VK_V).modifiers(InputEvent.CTRL_MASK);
+    widget.pressAndReleaseKey(kpi);
+    }
+    
+    /*
+    public static void addMeta(String documentPath, String metaname, String metavalue) {
+    openCollectionPath(documentPath, CLICK);
+    JTableFixture metatable = window.table("MetadataValueTable");
+    JTableCellFixture cell = metatable.cell(metaname); // First matching metaname
+    //GLI has programmed behaviour that makes this code funny:
+    //It pre positions the cursor for you to enter the Next metaname
+    // But in assertJ swing testing code we need to access cells manually.
+    // But always clicking on value cell for metaname and hitting RETURN allows
+    // adding meta in correct cell. But we can only call enterValue() on row and column
+    // of a cell we know. So we need to find the table(row,col) of the cell GLI positioned
+    // us at after we press click and RETURN and then enter the value there.
+    cell.click();
+    PAUSE(0.5);
+    metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER);
+    PAUSE(0.5);
+    // table was modified by GLI, get it again?
+    metatable = window.table("MetadataValueTable");
+    // GLI should now automatically have positioned us in the cell we'd like to enter data
+    // GLI would have created a new row with the same metaname and empty metavalue field.
+    // Work out what the correct row of it is by calculating the row of the last matching
+    // metaname cell.
+    int row = cell.row();
+    int col = cell.column();
+    // Look for Last matching metaname
+    TableCell metanameCell;
+    do {        
+        metanameCell = TableCell.row(row).column(col);
+        row++; // check next row's metaname
+    } while(metatable.valueAt(TableCell.row(row).column(col)).equals(metaname));
+    
+    row = metatable.cell(metanameCell).row(); // found row with the last matching metaname
+
+    
+    
+    // metavalue is one column past from metaname
+    TableCell valueCell = TableCell.row(row).column(col+1);
+    System.err.println("#### row " + row + " should have no metaval: " + metatable.valueAt(valueCell));
+
+    //System.err.println("#### Metaname column: " + col + " value: " + metatable.valueAt(valueCell));
+    metatable.enterValue(valueCell, metavalue);
+    }
+    */
+    
+    // WORKS!!!
+    public static void addMeta(String documentPath, String metaname, String metavalue) {
+    openCollectionPath(documentPath, CLICK);
+    JTableFixture metatable = window.table("MetadataValueTable");
+    JTableCellFixture cell = metatable.cell(metaname); // First matching metaname
+
+    int row = cell.row();
+    int col = cell.column();
+    // Look for Last matching metaname
+    TableCell metanameCell;
+    do {        
+        metanameCell = TableCell.row(row).column(col);
+        row++; // check next row's metaname
+
+        //row++; // check next row's metaname
+        //metanameCell = TableCell.row(row).column(col);
+    } while(metatable.valueAt(TableCell.row(row).column(col)).equals(metaname));
+    row = metatable.cell(metanameCell).row(); // found row with the last matching metaname
+
+    // On Enter press below, GLI will create a new empty row for the metaname for
+    // the new metadata to be added, so overcounting by 1 in the loop is what is needed
+    // and we *don't* want to go one row back. It just ends up working out.
+    //do {      
+    //    row++; // check next row's metaname
+    //    metanameCell = TableCell.row(row).column(col);
+    //} while(metatable.valueAt(metanameCell).equals(metaname));    
+
+    //metatable.cell(metanameCell).click();
+    // metavalue is one column past metaname
+    TableCell valueCell = TableCell.row(row).column(col+1); 
+    //metatable.enterValue(valueCell, metavalue);
+    System.err.println("#### Metaname column: " + col + " value: " + metatable.valueAt(valueCell));
+    //click on cell and hit enter to add meta       
+    metatable.cell(valueCell).click();
+    //PAUSE(0.5);
+    metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER);
+    //PAUSE(0.5);
+    valueCell = TableCell.row(row+1).column(col+1);
+    metatable.enterValue(valueCell, metavalue);
+    //metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER); // To make value stick?
+    }
+    // NOT WORKING
+    public static void addMetaValsToCurrentDoc(String metaname, String[] metavalues) {
+    JTableFixture metatable = window.table("MetadataValueTable");
+    JTableCellFixture cell = metatable.cell(metaname); // First matching metaname
+    int row = cell.row();
+    int col = cell.column();
+    TableCell valueCell = TableCell.row(row).column(col+1);
+
+    metatable.cell(valueCell).click();
+    metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER);
+    for(String metavalue : metavalues) {
+        System.err.println("### Copying to clipboard: " + metavalue);
+        putOnClipboard(metavalue);
+        
+        System.err.println("### Pasting from clipboard: " + getStringFromClipboard());
+        metatable.pressKey(java.awt.event.KeyEvent.VK_A);
+        metatable.pressKey(java.awt.event.KeyEvent.VK_N);
+        metatable.pressKey(java.awt.event.KeyEvent.VK_U);
+        //pasteClipboard(metatable);
+        //KeyPressInfo kpi = keyCode(java.awt.event.KeyEvent.VK_V).modifiers(InputEvent.SHIFT_MASK);
+        KeyPressInfo kpi = keyCode(java.awt.event.KeyEvent.VK_V).modifiers(InputEvent.CTRL_MASK);
+        metatable.pressAndReleaseKey(kpi);
+        metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER);
+        //PAUSE(0.5);
+    }
+
+    /*
+    int row = cell.row();
+    int col = cell.column();
+    // Look for Last matching metaname
+    TableCell metanameCell;
+    do {        
+        metanameCell = TableCell.row(row).column(col);
+        row++; // check next row's metaname
+
+        //row++; // check next row's metaname
+        //metanameCell = TableCell.row(row).column(col);
+    } while(metatable.valueAt(TableCell.row(row).column(col)).equals(metaname));
+    row = metatable.cell(metanameCell).row(); // found row with the last matching metaname
+
+    // On Enter press below, GLI will create a new empty row for the metaname for
+    // the new metadata to be added, so overcounting by 1 in the loop is what is needed
+    // and we *don't* want to go one row back. It just ends up working out.
+    //do {      
+    //    row++; // check next row's metaname
+    //    metanameCell = TableCell.row(row).column(col);
+    //} while(metatable.valueAt(metanameCell).equals(metaname));    
+
+    //metatable.cell(metanameCell).click();
+    // metavalue is one column past metaname
+    TableCell valueCell = TableCell.row(row).column(col+1); 
+    //metatable.enterValue(valueCell, metavalue);
+    System.err.println("#### Metaname column: " + col + " value: " + metatable.valueAt(valueCell));
+    //click on cell and hit enter to add meta       
+    metatable.cell(valueCell).click();
+    metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER);
+    metatable.enterValue(valueCell, metavalues[0]);
+    
+    for(String metavalue : metavalues) {
+        
+        // MIXED THIS UP IN TRYING TO GET IT TO WORK
+          metatable.enterValue(valueCell, metavalue);
+        //need to refresh table model, as a row was added
+        metatable = window.table("MetadataValueTable");
+        row++;      
+        valueCell = TableCell.row(row).column(col+1);
+        metatable.cell(valueCell).click();
+        metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER);
+        
+    }
+    */
+    /*
+    //PAUSE(0.5);
+    for(String metavalue : metavalues) {
+        row = metatable.cell(metanameCell).row();
+        metatable.cell(metanameCell).click();
+        
+        // do something with new row created automatically by GLI
+        // metatable.valueAt(TableCell.row(row+1).column(col));
+           
+        //PAUSE(0.5);
+        //row++;
+        // get current row again
+        metanameCell = TableCell.row(row).column(col);
+        if(metatable.valueAt(metanameCell).equals(metaname)) {
+        valueCell = TableCell.row(row).column(col+1);
+        metatable.enterValue(valueCell, metavalue);
+        }
+        metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER);
+    }*/
+    }
+    
+    public static void addMeta(String documentPath, Collection<SimpleEntry<String, Object>> metadata) {
+    openCollectionPath(documentPath, CLICK);
+    JTableFixture metatable = window.table("MetadataValueTable");
+
+    Iterator<SimpleEntry<String, Object>> it = metadata.iterator();
+    while(it.hasNext()) {
+        SimpleEntry<String, Object> entry = it.next();
+        String metaname = entry.getKey();       
+        Object value = entry.getValue();
+
+        if(value instanceof String) {
+        String[] metavals = new String[1];
+        metavals[0] = (String)value;
+        addMetaValsToCurrentDoc(metaname, metavals);
+        } else {
+        Collection<String> valueList = (Collection<String>)value;
+        String[] metavals = new String[valueList.size()];
+        metavals = valueList.toArray(metavals);
+        addMetaValsToCurrentDoc(metaname, metavals);
+        }
+    }   
+    }
+    
+    /*
+    public static void addMeta(String documentPath, String metaname, String metavalue) {
+    openCollectionPath(documentPath, CLICK);
+    JTableFixture metatable = window.table("MetadataValueTable");
+    JTableCellFixture cell = metatable.cell(metaname);
+    int row = cell.row();
+    int col = cell.column();
+    
+    TableCell valueCell = TableCell.row(row).column(col+1);
+    while(!metatable.valueAt(valueCell).equals("")) {
+        //click on cell and hit enter to add meta       
+        metatable.cell(valueCell).click();
+        //PAUSE(2);
+        metatable.pressKey(java.awt.event.KeyEvent.VK_ENTER);
+        //PAUSE(2);
+        row = row+1;
+        valueCell = TableCell.row(row).column(col+1);
+        System.err.println("*** |" + metatable.valueAt(valueCell) + "|");
+    }
+    
+    metatable.enterValue(valueCell, metavalue);
+    System.err.println("#### Metaname column: " + col);
+    
+    }
+    */
+    /*
+    public static void setMeta(String document, Map<String, Object> metadataMap) {
+    //Set<Map.Entry<String, Object>> metadataSet = metadataMap.entrySet();
+    //Iterator<Map.Entry<String, Object>> i = metadataSet.iterator();
+    //i.next();
+    Set<String> metanames = metadataMap.keySet();
+    for(String metaname : metanames) {
+        Object value = metadataMap.get(metaname);
+        if(value instanceof String) {
+        setMeta(document, metaname, (String)value);
+        } else {
+        List<String> valueList = (List<String>)value;
+        for(String metavalue : valueList) {
+            setMeta(document, metaname, metavalue);
+        }
+        }
+    }   
+    }
+    */
+
+    // https://stackoverflow.com/questions/6121246/list-of-entries-how-to-add-a-new-entry
+    // Google: Java List of SimpeEntry    
+    public static void setMeta(String document, Collection<SimpleEntry<String, Object>> metadata) {
+    //Set<Map.Entry<String, Object>> metadataSet = metadataMap.entrySet();
+    //Iterator<Map.Entry<String, Object>> i = metadataSet.iterator();
+    //i.next();
+    Iterator<SimpleEntry<String, Object>> metaEntries = metadata.iterator();
+    while(metaEntries.hasNext()) {
+        SimpleEntry<String, Object> meta = metaEntries.next();
+        String metaname = meta.getKey();
+        Object value = meta.getValue();
+        if(value instanceof String) {
+        setMeta(document, metaname, (String)value);
+        } else {
+        Collection<String> valueList = (Collection<String>)value;
+        for(String metavalue : valueList) {
+            setMeta(document, metaname, metavalue);
+        }
+        }
+    }   
+    }
     /********************* DOWNLOAD PANE ******************/
     // TODO: more functions needed here: e.g. serverInfo?