data/test.py

import contextlib
from concurrent.futures import ThreadPoolExecutor, as_completed
from selenium import webdriver
from selenium.webdriver.chrome.service import Service as ChromeService
from webdriver_manager.chrome import ChromeDriverManager
from selenium.webdriver.support.wait import WebDriverWait
from selenium.webdriver.common.by import By
from selenium.common.exceptions import TimeoutException, ElementNotInteractableException
from selenium.webdriver.support import expected_conditions as EC
from selenium.webdriver.chrome.options import Options
from selenium.webdriver.chrome.service import Service
from selenium.webdriver.common.action_chains import ActionChains
from selenium.webdriver.common.keys import Keys
from json.decoder import JSONDecodeError
import html
from simple_term_menu import TerminalMenu
import shutil
import subprocess
import html
import random

# import traceback
import threading

import json
import time
import re
import glob
import sys
import os

# import LogEntries, LogType, Level
# from selenium.webdriver.logging import LogEntries
# from selenium.webdriver.logging import LogType

# DEVTOOLS flag to control the automatic opening of Chrome DevTools.
DEVTOOLS = True

# Make a menu to select the url
urls = [
    "http://localhost:8080",
    # "https://durrantlab.pitt.edu/apps/molmoda/beta/",
    # "https://durrantlab.pitt.edu/molmoda/",
    "https://molmoda.org",
    "https://beta.molmoda.org",
]

menu = TerminalMenu(urls, title="Select the root URL")
chosen_index = menu.show()
root_url = urls[chosen_index]

browsers_to_use = []
browser_choices = [
    "[s] standard three",
    "chrome",
    "chrome-headless",
    "firefox",
    "firefox-headless",
    "safari",
    "[d] done",
]
menu = TerminalMenu(browser_choices, title="Select the browsers to use")

while True:
    print("Selected browsers: " + ", ".join(browsers_to_use))
    chosen_index2 = menu.show()
    if chosen_index2 == len(browser_choices) - 1:
        # Done
        break
    if browser_choices[chosen_index2] == "[s] standard three":
        browsers_to_use.extend(["chrome-headless", "firefox", "safari"])
    else:
        browsers_to_use.append(browser_choices[chosen_index2])
    browsers_to_use = list(set(browsers_to_use))
    browsers_to_use.sort()

print("\nUsing root URL: " + root_url)


class el:
    def __init__(self, selector, drvr, timeout=50):
        self.selector = selector
        self.timeout = timeout
        self.driver = drvr
        self.poll_frequency_secs = 2

        try:
            self.el = WebDriverWait(
                drvr, self.timeout, poll_frequency=self.poll_frequency_secs
            ).until(lambda drvr: drvr.find_element(By.CSS_SELECTOR, selector))
        except TimeoutException as e:
            self.throw_error(f"{self.selector} not found after {self.timeout} seconds")

    @property
    def text(self):
        txt = self.el.get_attribute("value")
        if txt in [None, ""]:
            txt = self.el.get_attribute("innerHTML")

        return txt

    # @property
    # def text(self):
    #     # First, try to get the text using the more reliable 'textContent' attribute.
    #     txt = self.el.get_attribute("textContent")
    #     if txt:
    #         # The textContent might have leading/trailing whitespace.
    #         return txt.strip()

    #     # Fallback to innerHTML if textContent is empty for some reason.
    #     txt = self.el.get_attribute("innerHTML")
    #     if txt:
    #         return txt.strip()

    #     # Finally, check the 'value' attribute, which is useful for input elements.
    #     return self.el.get_attribute("value")

    @text.setter
    def text(self, value):
        # Clear the field
        try:
            self.el.clear()
        except Exception as e:
            pass

        # Type the value
        with contextlib.suppress(Exception):
            value = html.unescape(value)
        if value == "BACKSPACE":
            self.el.send_keys(Keys.BACKSPACE)
        else:
            self.el.send_keys(value)
        self.check_errors()

    @property
    def value(self):
        # Alias
        return self.text

    @value.setter
    def value(self, value):
        # Alias
        self.text = value

    def wait_until_text_is_not(self, text="", timeout=None):
        if timeout is None:
            timeout = self.timeout

        # Good for waiting for AJAX or text changes
        try:
            WebDriverWait(
                self.driver, self.timeout, poll_frequency=self.poll_frequency_secs
            ).until_not(lambda driver: self.text == text)
        except TimeoutException as e:
            self.throw_error(
                f"{self.selector} still [[{text}]] after {self.timeout} seconds"
            )

    def click(self, shiftPressed=False):
        try:
            if shiftPressed:
                # Key down
                # import pdb; pdb.set_trace()
                ActionChains(self.driver).key_down(Keys.SHIFT).perform()
            self.el.click()
            if shiftPressed:
                # Key up
                ActionChains(self.driver).key_up(Keys.SHIFT).perform()

            self.check_errors()
        except ElementNotInteractableException as e:
            # print(e)
            self.throw_error(f"{self.selector} not clickable")

    def upload_file(self, file_path):
        file_path = os.path.realpath(file_path)
        self.el.send_keys(file_path)
        self.check_errors()

    def checkBox(self, value):
        # Get current value of checkbox
        current_value = self.el.get_attribute("checked") == "true"

        if value != current_value:
            self.el.click()

    def wait_until_contains_regex(self, regex):

        # Define a lambda function to check if the element's innerHTML matches the regex
        try:
            regex = html.unescape(regex)
            wait = WebDriverWait(
                self.driver, self.timeout, poll_frequency=self.poll_frequency_secs
            )

            def check(driver):
                # inner_html = self.el.get_attribute("innerHTML")
                text_content = self.text

                # print(f"Checking innerHTML: {inner_html}")  # Print the innerHTML for debugging
                # with open("tmp.txt", "w") as f:
                #     f.write(inner_html)
                # os.system("cat tmp.txt | pbcopy; rm tmp.txt")

                # return re.search(regex, inner_html)
                return re.search(regex, text_content)

            self.el = wait.until(check)
            # .until(lambda driver: re.search(regex, self.el.get_attribute("innerHTML")))
        except TimeoutException as e:
            self.throw_error(
                f"{self.selector} does not contain [[{regex}]] after {self.timeout} seconds; Actual text: [[{self.text}]]"
            )

    def wait_until_does_not_contain_regex(self, regex):
        try:
            regex = html.unescape(regex)
            WebDriverWait(
                self.driver, self.timeout, poll_frequency=self.poll_frequency_secs
            ).until_not(lambda driver: re.search(regex, self.text))
            # ).until_not(lambda driver: re.search(regex, self.el.get_attribute("innerHTML")))
        except TimeoutException as e:
            self.throw_error(
                f"{self.selector} still contains [[{regex}]] after {self.timeout} seconds"
            )

    def check_errors(self):
        # Run after every action
        # Wait 0.5 seconds
        time.sleep(0.5)

        # Check for errors
        err = el("#test-error", self.driver)
        if err.text != "":
            self.throw_error(err.text)

    def throw_error(self, msg):
        # Run after every action

        if not msg.endswith("."):
            msg += "."

        # print("\nLOGS:")
        # print("=====\n")
        # logs = self.driver.get_log("browser")
        # for log in logs:
        #     print(log["level"] + " :: " + log["message"])
        # print("\n=====\n")

        # Run alert in browser with msg
        # self.driver.execute_script(
        #     f"alert('ERROR: {msg} See terminal for more details.')"
        # )

        # print(msg)
        # input("Press Enter to end all tests...")
        # self.driver.quit()
        raise Exception(msg)


def make_chrome_driver(options):
    # If DEVTOOLS is True, add the argument to open DevTools automatically.
    if DEVTOOLS:
        options.add_argument("--auto-open-devtools-for-tabs")

    service = Service(executable_path="utils/chromedriver_wrapper.sh")
    options.set_capability("goog:loggingPrefs", {"browser": "ALL"})
    driver = webdriver.Chrome(service=service, options=options)

    # Check if the root_url is a localhost URL.
    if "localhost" in root_url or "127.0.0.1" in root_url:
        # Enable the Network domain of the Chrome DevTools Protocol.
        driver.execute_cdp_cmd("Network.enable", {})

        # Setting a blanket Origin header can cause CORS issues with external sites.
        # Modern browsers treat localhost as a secure context, so this override is often
        # not necessary and can be detrimental for tests involving multiple origins.
        # driver.execute_cdp_cmd('Network.setExtraHTTPHeaders', {'headers': {'Origin': root_url}})

    return driver


def make_driver(browser):
    driver = None
    if browser == "firefox":
        options = webdriver.FirefoxOptions()

        # Firefox can run in headless, but I prefer not. Good to have GUI just
        # in case introduces some errors (don't trust headless). Will run chrome
        # in headless, because it otherwise steals the focus.
        # options.add_argument("-headless")

        driver = webdriver.Firefox(options=options)
        driver.maximize_window()
    elif browser == "firefox-headless":
        input(
            "Could get an error here (untested). Involving e.php. If so, it's because firefox-headless doesn't send the Origin header with 'localhost' in it..."
        )
        options = webdriver.FirefoxOptions()
        options.add_argument("-headless")
        options.add_argument("--width=1920")
        options.add_argument("--height=1080")
        driver = webdriver.Firefox(options=options)
    elif browser == "safari":
        # Note importance of disabling certain features in safari to make it
        # work: https://developer.apple.com/forums/thread/709225
        driver = webdriver.Safari()
        driver.maximize_window()
        os.system("""osascript -e 'tell application "Safari" to activate'""")
    elif browser == "chrome":
        # NOTE: If this ever starts running really slow, you probably aren't
        # using arm64-compiled version of chrome.

        # brew install chromedriver (to update too)

        # Java on mac can run in both arm64 and x86_64. This forces arm64, since
        # you test on a mac.
        options = webdriver.ChromeOptions()
        options.add_argument("--start-maximized")
        options.add_argument("--window-size=1920,1080")
        driver = make_chrome_driver(options)
    elif browser == "chrome-headless":
        options = webdriver.ChromeOptions()
        # Chrome works well in headless! Also, prevents stealing focus.
        options.add_argument("--headless=new")
        options.add_argument("--start-maximized")
        options.add_argument("--window-size=1920,1080")
        # Set a common user agent to make the headless browser appear more like a standard browser.
        options.add_argument(
            "user-agent=Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
        )
        driver = make_chrome_driver(options)
    return driver


def do_logs_have_errors(driver, browser):
    if "firefox" in browser.lower():
        # Firefox driver has no get_log method
        return False

    logs = driver.get_log("browser")

    # Get all the logs that are SEVERE, WARNING, or ERROR
    logs_to_keep = [l for l in logs if l["level"] in ["SEVERE", "ERROR"]]

    # Don't keep ones with "404 (Not Found)". This should be handeled
    # separately.
    logs_to_keep = [
        l
        for l in logs_to_keep
        if "message" in l
        and "status of 404" not in l["message"]
        and "status code 404" not in l["message"]
        and "status of 400" not in l["message"]
        and "404 (Not Found)" not in l["message"]
        # Very annoying that www.ebi.ac.uk throws CORS errors instead of 404...
        and not (
            "https://www.ebi.ac.uk/" in l["message"]
            and "blocked by CORS policy" in l["message"]
        )
        and not (
            "https://www.ebi.ac.uk/" in l["message"]
            and "Failed to load resource" in l["message"]
        )
    ]

    if not logs_to_keep:
        return False
    else:
        return " ".join([l["message"] for l in logs_to_keep])


allowed_threads = {
    "chrome": 4,
    "chrome-headless": 4,
    "firefox": 4,
    "firefox-headless": 4,
    "safari": 1,
}

drivers = {}
browser = ""


def check_errors(driver, browser):
    # Check for JavaScript errors in the browser console
    js_errs = do_logs_have_errors(driver, browser)
    if js_errs != False:
        if "user gesture" in js_errs:
            print(f"Ignored JavaScript error: {js_errs} (ignored, user gesture)")
        else:
            raise Exception(f"Critical JavaScript error: {js_errs}")
    return js_errs


def run_test(plugin_id_tuple):
    global drivers
    global browser

    try:
        key = threading.get_ident()
        if key not in drivers:
            drivers[key] = make_driver(browser)

        driver = drivers[key]

        try:
            plugin_name, plugin_idx = plugin_id_tuple
            test_lbl = (
                f"{plugin_name}{f' #{plugin_idx + 1}' if plugin_idx is not None else ''}"
            )
            # print(f"Starting test: {test_lbl}...")
            url = f"{root_url}/?test={plugin_name}"
            if plugin_idx is not None:
                url += f"&index={str(plugin_idx)}"
            driver.get(url)
            cmds_str = None
            cmds = None
            for _ in range(4):
                cmds_str = el("#test-cmds", driver).text
                try:
                    cmds = json.loads(cmds_str)
                    break
                except Exception as JSONDecodeError:
                    time.sleep(0.25)
            # MODIFICATION START: Replaced sys.exit(1) with an exception.
            # This allows the test runner to catch the failure, report it, and
            # continue with other tests instead of halting the entire suite.
            if cmds is None:
                raise Exception(
                    "No commands found. Are you sure you specified an actual plugin id?"
                )
            # MODIFICATION END
            if cmds_str is None:
                print(f"Failed to parse JSON: {cmds_str}")
                return {
                    "status": "failed",
                    "test": test_lbl,
                    "error": f"Failed to parse JSON: {cmds_str}",
                }

            screenshot_dir = f"./screenshots/{test_lbl}"
            if os.path.exists(screenshot_dir):
                shutil.rmtree(screenshot_dir)
            if not os.path.exists("./screenshots"):
                os.makedirs("./screenshots")
            if not os.path.exists(screenshot_dir):
                os.makedirs(screenshot_dir)

            # print(f"Starting {test_lbl}...")
            try:
                # print(json.dumps(cmds, indent=4))
                for cmd_idx, cmd in enumerate(cmds):
                    # print(cmd)
                    # resp += f"   {json.dumps(cmd)}\n"
                    if cmd["cmd"] == "click":
                        el(cmd["selector"], driver).click(
                            cmd["data"] if "data" in cmd else False
                        )
                    elif cmd["cmd"] == "text":
                        el(cmd["selector"], driver).text = cmd["data"]
                    elif cmd["cmd"] == "wait":
                        time.sleep(cmd["data"])
                    elif cmd["cmd"] == "waitUntilRegex":
                        el(cmd["selector"], driver).wait_until_contains_regex(cmd["data"])
                    elif cmd["cmd"] == "waitUntilNotRegex":
                        el(cmd["selector"], driver).wait_until_does_not_contain_regex(
                            cmd["data"]
                        )
                    elif cmd["cmd"] == "upload":
                        el(cmd["selector"], driver).upload_file(cmd["data"])
                    elif cmd["cmd"] == "addTests":
                        return [(plugin_name, i) for i in range(cmd["data"])]
                    elif cmd["cmd"] == "checkBox":
                        el(cmd["selector"], driver).checkBox(cmd["data"])
                    screenshot_path = f"{screenshot_dir}/{test_lbl}_{cmd_idx}.png"
                    driver.save_screenshot(screenshot_path)
                    js_errs = check_errors(driver, browser)
                    # js_errs = do_logs_have_errors(driver, browser)
                    # if js_errs != False:
                    #     if "user gesture" in js_errs:
                    #         print(f"Ignored JavaScript error: {js_errs} (ignored, user gesture)")
                    #     else:
                    #         raise Exception(f"Critical JavaScript error: {js_errs}")

                # resp = f"Passed: {test_lbl}"
                resp = {
                    "status": "passed",
                    "test": test_lbl,
                    "error": "",
                }
            except Exception as e:
                # Do a trace
                # Get the stack trace
                # stack_trace = traceback.format_exc()
                # print(stack_trace)
                # resp = f"Failed: {test_lbl} {e}"
                resp = {
                    "status": "failed",
                    "test": test_lbl,
                    "error": str(e),
                }
            js_errs = check_errors(driver, browser)
            # js_errs = do_logs_have_errors(driver, browser)
            # if js_errs != False:
            #     raise Exception(f"JavaScript error: {js_errs}")
            # driver.quit()
            return resp
        finally:
            # Clear browser storage to ensure a clean state for the next test
            with contextlib.suppress(Exception):
                driver.execute_script(
                    "window.localStorage.clear(); window.sessionStorage.clear();"
                )
    except Exception as e:
        if is_single_test_run:
            print(f"\nAn error occurred during test '{plugin_id_tuple[0]}'.")
            print(f"Error details: {e}")
            input(
                "The browser remains open for inspection. Press Enter to close it and proceed."
            )
        raise  # Re-raise the exception to be caught by the main thread pool loop.


# If first argument given, use that as plugin_id
if len(sys.argv) > 1:
    # job index also given.
    # subjob_idx = int(sys.argv[2]) - 1 if len(sys.argv) > 2 else None
    # plugin_ids = [(sys.argv[1], subjob_idx)]

    subjob_idx = None
    plugin_ids = []
    # Go through each of the arguments. If it's a number, set subjob_idx. If
    # it's a string, add it to plugin_ids.
    for arg in sys.argv[1:]:
        try:
            subjob_idx = int(arg) - 1
        except ValueError:
            plugin_ids.append(arg)

    # Now add the subjob_idx to the plugin_ids
    plugin_ids = [(i, subjob_idx) for i in plugin_ids]

else:
    # Get ID's of all plugins
    plugin_ids = []
    for ts_file in glob.glob("./src/**/*Plugin.vue", recursive=True):
        with open(ts_file, "r") as f:
            content = f.read()
        plugin_id = re.search(r'[^:]\bpluginId *?= *?"(.+)"', content, re.MULTILINE)[1]
        plugin_ids.append((plugin_id, None))

# Some plugins are not allowed
plugin_ids = [
    i
    for i in plugin_ids
    if "simplemsg" not in i[0] and "testplugin" not in i[0] and "redo" not in i[0]
]

# some plugins are disallowed only for safari
if "safari" in browsers_to_use:
    plugin_ids = [i for i in plugin_ids if "documentation" not in i[0]]

plugin_ids.sort()
# print(plugin_ids)

# For debugging
# plugin_ids = plugin_ids[:5]

# all_test_results = {}

# MODIFICATION: Determine if this is a single test run to enable pausing on error.
is_single_test_run = len(plugin_ids) == 1

passed_tests = []
failed_tests = []  # MODIFICATION: Added a global failed_tests list

for browser_to_use in browsers_to_use:
    # Set global var
    browser = browser_to_use

    print("\nBrowser: " + browser + "\n")

    plugin_ids_per_browser = plugin_ids.copy()

    for try_idx in range(4):
        # MODIFICATION: Reset failed_tests_this_round for each attempt
        failed_tests_this_round = []
        drivers = {}

        # MODIFICATION: Shuffle the list of tests to be run in this round for randomness.
        random.shuffle(plugin_ids_per_browser)

        with ThreadPoolExecutor(
            max_workers=allowed_threads[browser_to_use]
        ) as executor:
            # Use a dictionary to map futures to the tests they represent
            # (optional but can be useful)
            futures_to_tests = {}

            results = []

            while plugin_ids_per_browser or futures_to_tests:
                # While there are tests to submit or futures that haven't been processed
                while plugin_ids_per_browser:
                    # MODIFICATION: Use pop() to take a random test from the shuffled list.
                    test = plugin_ids_per_browser.pop()
                    future = executor.submit(run_test, test)
                    futures_to_tests[future] = test

                # Use as_completed to gather results and remove completed futures
                for future in as_completed(futures_to_tests):
                    test = futures_to_tests[future]
                    try:
                        result = future.result()

                        # Is result a list?
                        if isinstance(result, list):
                            plugin_ids_per_browser = result + plugin_ids_per_browser
                            # print(f"Added tests: {json.dumps(result)}")
                            continue

                        # Not a list, so do nothing.
                        print(
                            f"{result['status'][:1].upper()}{result['status'][1:]}: {result['test']} {result['error']}"
                        )
                        if result["status"] == "passed":
                            # MODIFICATION: Append the result dictionary to passed_tests
                            passed_tests.append(
                                {
                                    **result,
                                    "try": try_idx + 1,
                                    "browser": browser_to_use,
                                }
                            )
                        else:
                            # MODIFICATION: Append the original test tuple to the list for retrying
                            failed_tests_this_round.append(test)
                            # MODIFICATION: Append the full result to the global failed_tests list for reporting
                            failed_tests.append(
                                {
                                    **result,
                                    "try": try_idx + 1,
                                    "browser": browser_to_use,
                                }
                            )
                    except Exception as e:
                        print(f"Test {test} raised an exception: {e}")
                        # MODIFICATION: Append the original test tuple for retrying
                        failed_tests_this_round.append(test)
                        # MODIFICATION: Append a constructed error result for reporting
                        failed_tests.append(
                            {
                                "status": "failed",
                                "test": f"{test[0]}{f' #{test[1] + 1}' if test[1] is not None else ''}",
                                "error": str(e),
                                "try": try_idx + 1,
                                "browser": browser_to_use,
                            }
                        )
                    finally:
                        del futures_to_tests[future]

        # MODIFICATION: Use the list of failed tests from this round for the next retry
        plugin_ids_per_browser = failed_tests_this_round
        plugin_ids_per_browser.sort()

        # Go through all the drivers and quit
        for driver in drivers.values():
            driver.quit()
            if browser == "safari":
                # Safari refuses to quit.
                time.sleep(1)
                os.system("pkill -9 Safari > /dev/null 2>&1")
                time.sleep(1)

        if not plugin_ids_per_browser:
            break

        plugin_ids_str = ", ".join(
            [
                i[0] if i[1] is None else f"{i[0]} #{str(i[1] + 1)}"
                for i in plugin_ids_per_browser
            ]
        )
        print(f"Will retry the following tests: {plugin_ids_str}")


# import pdb; pdb.set_trace()

# MODIFICATION START: Simplified the final reporting loops
print("")
print("Tests that passed:")
for result in passed_tests:
    print(f"   {result['test']}-{result['browser']} (try {result['try']})")

print("")
print("Tests that failed:")
unique_failed_tests = {f"{t['test']}-{t['browser']}": t for t in failed_tests}.values()
if not unique_failed_tests:
    print("   None!")
else:
    for result in unique_failed_tests:
        print(
            f"   {result['test']}-{result['browser']} (Final Error: {result['error']})"
        )
# MODIFICATION END

print("")
print(urls[chosen_index] + "\n")

if failed_tests:
    failed_summary = {}
    for t in failed_tests:
        parts = t["test"].split(" #")
        name = parts[0]
        if name not in failed_summary:
            failed_summary[name] = {"indices": set(), "no_index_failed": False}
        if len(parts) > 1:
            failed_summary[name]["indices"].add(int(parts[1]))
        else:
            failed_summary[name]["no_index_failed"] = True

    run_again_parts = []
    for name in sorted(failed_summary.keys()):
        summary = failed_summary[name]
        if summary["no_index_failed"]:
            run_again_parts.append(name)
        elif summary["indices"]:
            indices = summary["indices"]
            indices_str = "".join(map(str, sorted(list(indices))))
            run_again_parts.append(f"{name}({indices_str})")

    print(f" RUN AGAIN (FAILED)?: {' '.join(run_again_parts)}")
# input("Done. Press Enter to end all tests...")

# driver.quit()

# Also run all jest tests
input("Press Enter to run all jest unit tests...")
os.system("node_modules/.bin/jest")