source: gs3-extensions/testing/trunk/src/src/org/greenstone/gsdl3/testing/GSGUITestingUtil.java@ 32714

package org.greenstone.gsdl3.testing;

import java.io.File;
import java.util.Map;
import java.util.regex.*;
import java.awt.Component;

// only JUnit and JAssert-Swing, no Selenium in this class
import org.junit.Assert;
import org.assertj.swing.fixture.*;
import org.assertj.swing.timing.Timeout ;
        

// GLI imports
import org.greenstone.gatherer.Gatherer;
import org.greenstone.gatherer.GathererProg; // main GLI class we'll be testing
import org.greenstone.gatherer.Dictionary; // access to display strings


// Java GUI testing with AssertJ Swing
import org.assertj.swing.junit.testcase.AssertJSwingJUnitTestCase;
import org.assertj.swing.fixture.*;
import org.assertj.swing.edt.GuiActionRunner;
import org.assertj.swing.core.Robot;


// static imports
import static org.assertj.swing.launcher.ApplicationLauncher.*;
import static org.assertj.swing.finder.WindowFinder.findFrame;

/*
 * Utility class containing helper functions for GLI GUI testing using AsssertJ Swing 
*/

public class GSGUITestingUtil
{
    public static FrameFixture window = null;
    
    public static final boolean PAUSE_ON = true;
    
    public static final int SECOND = 1000; // 1000 ms
    
    public static final String DOWNLOAD_PANE = "Download"; 
    public static final String GATHER_PANE = "Gather"; 
    public static final String ENRICH_PANE = "Enrich"; 
    public static final String DESIGN_PANE = "Design"; 
    public static final String CREATE_PANE = "Create"; 
    public static final String FORMAT_PANE = "Format";
    
    
    /************** NEEDED FOR TESTING *************/
    // There's now a new method in GLI: GUIManager.setNamesRecursively()
    // that attempts to recursively call setName() on visible GUI components so that we
    // can have easier access to those GUI components when testing here through their names    

    /****************************** APPLICATION  *******************************/
    public static void PAUSE() {    
    PAUSE(5);
    }
    public static void PAUSE(int seconds) {
    if(!PAUSE_ON) return; // ignore calls to PAUSE
    
    // wait a couple of seconds again?
     try{
         Thread.sleep(seconds*SECOND);
     } catch(Exception e) {
         e.printStackTrace();
     }
    }    

    //public static void setWindow(FrameFixture w) { window = w; } // if we want to null window
    
    public static void runGLI() {
    //GathererProg frame = GuiActionRunner.execute(() -> new GathererProg());           
    
    // IMPORTANT, note the call to 'robot()': must use the Robot from AssertJSwingJUnitTestCase
    //window = new FrameFixture(robot(), frame);
    //window.show(); // shows the frame to test

    // Instead, we'll be launching GLI and then getting a ref to the launched app window:
      
    // Launch GathererProg.java's main() method
    // See https://joel-costigliola.github.io/assertj/assertj-swing-launch.html
    
    String GSDLOS = System.getenv("GSDLOS");
    String GSDLHOME = System.getenv("GSDLHOME");
    String GSDL3HOME = System.getenv("GSDL3HOME");
    String GSDL3SRCHOME = System.getenv("GSDL3SRCHOME");
    application("org.greenstone.gatherer.GathererProg").withArgs(
                                 "-gsdl", GSDLHOME,
                                 "-gsdlos", GSDLOS,
                                 "-gsdl3", GSDL3HOME,
                                 "-gsdl3src", GSDL3SRCHOME,
                                 "-testing_mode").start();
    // The -testing_mode flag passed into GLI above is a special flag
    // that calls GLI's TestingPreparating.setNamesRecursively()
    // to help testing by calling setName() on GUI components.
    }
    
    public static void exitGLI() {
    openMenuItem("file", "exit");
    }

    // Gets a ref to the main window (FrameFixture) of a running GLI
    public static FrameFixture getGLIApplicationWindow(Robot robot) {
    // locate and set the internal FrameFixture member variable 'window' and return a handle to it
    window = findFrame("GUIManager").using(robot); // GLI application JFrame's name is set to its classname, 'GUIManager'

    // https://joel-costigliola.github.io/assertj/swing/api/index.html?org/assertj/swing/launcher/ApplicationLauncher.html
    // "To change the speed of a GUI test, you need to change the values of both delayBetweenEvents and eventPostingDelay."
    //robot.settings().delayBetweenEvents(50);
    //robot.settings().eventPostingDelay(2*SECOND); // annoying, after every click!
    
    return window;
    }
    
    /****************************** BASICS  *******************************/

    
    //https://joel-costigliola.github.io/assertj/swing/api/org/assertj/swing/fixture/FrameFixture.html
    public static void switchToPane(String pane) {
    String paneLabel = Dictionary.get("GUI." + pane); // e.g. GUI.Enrich
    //JPanelFixture tab = window.panel(pane); // this just gets us the JPanel of controls within
    JTabbedPaneFixture tab = window.tabbedPane("GUIManager.tab_pane");
    tab.selectTab(paneLabel); // select tab by its title
    }
    public static void openMenuItem(String menu, String subMenu) {
    /*String menuLabel = Dictionary.get("Menu." + menu); // e.g. Menu.File
    window.menuItem(menuLabel).click(); //JMenuItemFixture.click()
    String subMenuLabel = Dictionary.get(menuLabel + "_" + subMenu); // e.g. Menu.File_Open
    window.menuItem(subMenuLabel).click();*/
    window.menuItem("MenuBar."+menu).click();
    window.menuItem("MenuBar."+menu+"_"+subMenu).click();
    }

    /*
    public static void stealAnyLock() {
    DialogFixture dialog = window.dialog("LockFileDialog");
    if(dialog != null) {
        dialog.button("LockFileDialog.ok_button").click();
    }
    }*/

    
    // e.g. pane = Enrich,view=collection; pane = Gather, view = workspace (or collection)
    public static void getFolderPath(String pane, String view, String folderPath) {}
    public static void getFilePath(String pane, String view, String filePath) {}
    
    /**********************FILE MENU*******************************/
    public static void setPrefs(String tab, Map params) {
    openMenuItem("file", "options");

    }
    
    /**
     * @param toMode must be the dictionary key for Preferences mode.
     * Choose from Preferences.Mode.Assistant, Preferences.Mode.Librarian, Preferences.Mode.Expert
     */
    public static void changeUserMode(String toMode) {
    openMenuItem("file", "options"); // click MenuBar.file -> MenuBar.file_options

    // switch to Mode tab
    String paneLabel = Dictionary.get("Preferences.Mode");
    DialogFixture dialog = window.dialog("Preferences");
    JTabbedPaneFixture tab = window.tabbedPane("Preferences.tab_pane");
    tab.selectTab(paneLabel); // select tab by its title

    String mode = "assistant"; // library assistant
    if(toMode.contains("xpert")) {
        mode = "expert";
    } else if (toMode.endsWith("ibrarian")) {
        mode = "librarian";
    }
    dialog.radioButton("Preferences."+mode+"_mode_radio_button").check(true);

    // apply and close dialog
    dialog.button("Preferences.apply_button").click();
    dialog.button("Preferences.ok_button").click();
    }

    
    public static void closeCollection(){
    // Through componennt names, clicks on MenuBar.file then MenuBar.file_close
    openMenuItem("file", "close");
    }

    public static void deleteCollection(String collName) {
    openMenuItem("file", "delete");
    DialogFixture dialog = window.dialog("DeleteCollectionPrompt"); // could call window.dialg() too as there will be only one, unless GLI run in debug mode?
    
    JListFixture collection_list = dialog.list("DeleteCollectionPrompt.list");
    
    Pattern collNameRegex = Pattern.compile(".*"+collName+".*");
    collection_list.selectItem(collNameRegex);
    
    collection_list.requireSelection(collNameRegex); // assert it exists and is selectable. Can't select (or delete) coll if it's open
    
    dialog.checkBox("DeleteCollectionPrompt.confirmation").check(true); // check checkbox to be sure to delete
    dialog.button("DeleteCollectionPrompt.ok_button").click(); // delete button

    // A close confirmation optionPane dialog appears - click OK in it
    dialog.optionPane().okButton().click();
    
    dialog.button("DeleteCollectionPrompt.close_button").click(); // close deleteColl dialog
    }
    
    public static void saveCollection() {
    openMenuItem("file", "save"); // MenuBar.file -> MenuBar.file_save
    }

    public static void createCollection(String collTitle, String collDescription, String baseColl)
    {
    openMenuItem("file", "new");
    DialogFixture dialog = window.dialog("col"); // GLI is unable to setName() of this dialog
    // to NewCollectioNDetailsPrompt. Not sure why.

    dialog.textBox("NewCollectionDetailsPrompt.title").enterText(collTitle); // JTextField
    if(collDescription != null && !collDescription.equals("")) {
        // JTextArea description
        dialog.textBox("NewCollectionDetailsPrompt.description").enterText(collDescription);
    }

    // JComboBox base_collection
    if(baseColl != null && !baseColl.equals("")) {
        JComboBoxFixture baseCollBox = dialog.comboBox("NewCollectionDetailsPrompt.base_collection");
        Pattern collNameRegex = Pattern.compile(".*"+baseColl+".*"); // comboBox should CONTAIN this string
        baseCollBox.selectItem(collNameRegex);
        baseCollBox.requireSelection(collNameRegex); // assert the baseColl name exists     
    }
    dialog.button("NewCollectionDetailsPrompt.create_button").click();
    }

    public static void loadCollection(String collName) {
    openMenuItem("file", "open");
    DialogFixture dialog = window.dialog("OpenCollectionDialog");
    JListFixture collection_list = dialog.list("OpenCollectionDialog.collection_list");

    // See section 4.2 of http://www.vogella.com/tutorials/JavaRegularExpressions/article.html
    // Apparently, testing Pattern "collName" expects it to match in entirety
    // whereas testing ".*collName.*" will test the string contains this Pattern
    Pattern collNameRegex = Pattern.compile(".*"+collName+".*");
    
    /*String[] items = collection_list.contents();
    for(String item : items) {
        System.err.println("@@@ ITEM: " + item);
        }*/
    

    //JListItemFixture collItem = collection_list.item(collNameRegex);
    //collItem.click();
    //collection_list.requireSelection(collNameRegex); // assert that the requested collection exists
    //collItem.doubleClick();
    collection_list.selectItem(collNameRegex);
    collection_list.requireSelection(collNameRegex); // assert that the requested collection exists

    
    /*String[] selections = collection_list.selection();
    for(String s : selections) {
        System.err.println("@@@ opening collection " + s);
        }*/

    JListItemFixture selectedColl = collection_list.item(collNameRegex);
    //collection_list.doubleClick(); // will double-click on last item regardless of what's selected
    selectedColl.doubleClick();

    //steal any lock
    /*
    DialogFixture dialog = window.dialog("LockFileDialog");
    if(dialog != null) {
        dialog.button("LockFileDialog.ok_button").click();
    }
    */
    }

    /**
     * @param exportColl has to be internal GS collection name, e.g. lucene-jdbm-demo
     * not public collection name like "Demo Collection".
     */
    public static void exportCollection(String exportToFormat, String exportColl)
    {
    openMenuItem("file", "exportas"); // Clicks MenuBar.file -> MenuBar.file_exportas

    DialogFixture dialog = window.dialog("ExportAsPrompt"); 
    dialog.comboBox("ExportAsPrompt.saveas_combobox").selectItem(exportToFormat);
    
    Pattern collNameRegex = Pattern.compile(".*"+exportColl+".*");
    JListFixture collection_list = dialog.list("ExportAsPrompt.list");
    collection_list.selectItem(collNameRegex); //JList of collections
    collection_list.requireSelection(collNameRegex); // check it exists

    dialog.button("ExportAsPrompt.ok_button").click(); // do export

    // first we see a progress dialog
    
    // Wait for subsequent export complete dialog
    DialogFixture exportCompleteDialog = window.dialog("SimpleResultDialog", Timeout.timeout(30*SECOND));

    // non-modal dialog, so give it focus, so we can close it through its Close button
    exportCompleteDialog.focus();
    
    //exportCompleteDialog.button().click();
    exportCompleteDialog.button("SimpleResultDialog.GLIButton."+Dictionary.get("General.Close")).click(); // it only has a single button: "Close", still want to future proof if more buttons get added by specifying the particular button


    // Close outer dialog too - cancel doubles as close button now that export is complete
    dialog.button("ExportAsPrompt.cancel_button").click();
    
    File file = new File(System.getenv("GSDLHOME") + File.separator + "tmp" + File.separator + "exported_"+exportColl+"_"+exportToFormat);

    Assert.assertTrue(file.exists());
    Assert.assertTrue(file.isDirectory());  
    }
    
    /*************** DESIGN ******************************/
    public static void changeIndexer(String toIndexer) {}
    public static void changeDB(String toDB) {}

    public static void configurePartitionIndex(String tab, Map params) {}
    
    public static void configurePlugin(String pluginName, Map params) {
    }

    public static void configureClassifier(String classifierName, Map params) {}

    public static void configurePlugout(String plugoutName, Map params) {}
    
    // https://www.journaldev.com/1257/java-varargs
    // https://www.geeksforgeeks.org/variable-arguments-varargs-in-java/
    public static void keepOnlyPlugins(String ... plug_n) {}

    public static void removePlugs(String ... plug_n) {}

    /********************** CREATE PANEL ********************/
    public static void buildOpenCollection() {}
    public static void buildOpenCollection(boolean minimalRebuild) {}
    public static void configureImportOptions(Map params) {}
    public static void configureBuildOptions(Map params) {}
    
    public static void buildOutputContains(String ... n) {}

    /******************** GATHER PANE ********************/
    public static void createWorkspaceShortcut(){}

    // in current open collection
    public static void createCollectionSubfolder() {}
    
    public static void dragNDrop(String workspacePath, String collPath) {}

    /********************* ENRICH PANE ******************/
    // docPath can be just docName or collectionSubfolder/Subfolder2/docName
    public static void addMeta(String docPath, Map metanamesToValues) {}
    public static void addFolderLevelMeta(String folderPath, Map metanamesToValues) {}

    /********************* DOWNLOAD PANE ******************/
    // TODO: more functions needed here: e.g. serverInfo?
    public static void download(String downloader, Map params) {}
    public static void clearCache() {}
    public static String serverInfo() {
    return "";
    }
    
    /********************* DOWNLOAD PANE ******************/
    public static void formatGeneral(){}
    public static void formatSearch() {}
    public static void formatFeature(String featureName, String filename) {}
    public static boolean isFormatFeatureXMLValid() {
    return true;
    }


    /********************* GEMS ******************/
    
    // TODO:
    public static void runGEMS() {}
    public static void exitGEMS() {}
    public static FrameFixture getGEMSApplicationWindow(Robot robot) {
    // TODO: don't forget to set internal member variable called 'window' before returning it
    return window;
    }
    
    // Moving these working bits of code here, in case I can use them to right
    // general get methods that make use of the GenericTypeMatcher method of accessing components
    // See https://joel-costigliola.github.io/assertj/assertj-swing-lookup.html

    /*window = findFrame(new GenericTypeMatcher<JFrame>(JFrame.class) {
          protected boolean isMatching(JFrame window) {
          return window.getTitle().trim().startsWith(expectedWindowTitle)
          && window.isShowing();
          }
      }).using(robot());
      */
    /*
    JTabbedPaneFixture tab = window.tabbedPane(new GenericTypeMatcher<JTabbedPane>(JTabbedPane.class) {
        @Override protected boolean isMatching(JTabbedPane tabPane) {
            System.err.println("### trying for match");
            //int index = GuiActionRunner.execute(() -> tabPane.getSelectedIndex());
            int index = tabPane.getSelectedIndex();
            String selectedTabTitle = tabPane.getTitleAt(index); //GuiActionRunner.execute(() -> tabPane.getTitleAt(index));
            System.err.println("### GOT TITLE: " + selectedTabTitle);
            return gatherPaneLabel.equals(selectedTabTitle);
        }
        });
    */
}