| import argparse | |
| import os | |
| import platform | |
| import shutil | |
| import subprocess | |
| import sys | |
| import tarfile | |
| from distutils.spawn import find_executable | |
| wpt_root = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir, os.pardir)) | |
| sys.path.insert(0, os.path.abspath(os.path.join(wpt_root, "tools"))) | |
| from . import browser, utils, virtualenv | |
| logger = None | |
| class WptrunError(Exception): | |
| pass | |
| class WptrunnerHelpAction(argparse.Action): | |
| def __init__(self, | |
| option_strings, | |
| dest=argparse.SUPPRESS, | |
| default=argparse.SUPPRESS, | |
| help=None): | |
| super(WptrunnerHelpAction, self).__init__( | |
| option_strings=option_strings, | |
| dest=dest, | |
| default=default, | |
| nargs=0, | |
| help=help) | |
| def __call__(self, parser, namespace, values, option_string=None): | |
| from wptrunner import wptcommandline | |
| wptparser = wptcommandline.create_parser() | |
| wptparser.usage = parser.usage | |
| wptparser.print_help() | |
| parser.exit() | |
| def create_parser(): | |
| from wptrunner import wptcommandline | |
| parser = argparse.ArgumentParser(add_help=False) | |
| parser.add_argument("product", action="store", | |
| help="Browser to run tests in") | |
| parser.add_argument("--yes", "-y", dest="prompt", action="store_false", default=True, | |
| help="Don't prompt before installing components") | |
| parser.add_argument("--stability", action="store_true", | |
| help="Stability check tests") | |
| parser.add_argument("--install-browser", action="store_true", | |
| help="Install the latest development version of the browser") | |
| parser._add_container_actions(wptcommandline.create_parser()) | |
| return parser | |
| def exit(msg): | |
| logger.error(msg) | |
| sys.exit(1) | |
| def args_general(kwargs): | |
| kwargs.set_if_none("tests_root", wpt_root) | |
| kwargs.set_if_none("metadata_root", wpt_root) | |
| kwargs.set_if_none("manifest_update", True) | |
| if kwargs["ssl_type"] == "openssl": | |
| if not find_executable(kwargs["openssl_binary"]): | |
| if os.uname()[0] == "Windows": | |
| raise WptrunError("""OpenSSL binary not found. If you need HTTPS tests, install OpenSSL from | |
| https://slproweb.com/products/Win32OpenSSL.html | |
| Ensuring that libraries are added to /bin and add the resulting bin directory to | |
| your PATH. | |
| Otherwise run with --ssl-type=none""") | |
| else: | |
| raise WptrunError("""OpenSSL not found. If you don't need HTTPS support run with --ssl-type=none, | |
| otherwise install OpenSSL and ensure that it's on your $PATH.""") | |
| def check_environ(product): | |
| if product not in ("firefox", "servo"): | |
| expected_hosts = ["web-platform.test", | |
| "www.web-platform.test", | |
| "www1.web-platform.test", | |
| "www2.web-platform.test", | |
| "xn--n8j6ds53lwwkrqhv28a.web-platform.test", | |
| "xn--lve-6lad.web-platform.test", | |
| "nonexistent-origin.web-platform.test"] | |
| missing_hosts = set(expected_hosts) | |
| if platform.uname()[0] != "Windows": | |
| hosts_path = "/etc/hosts" | |
| else: | |
| hosts_path = "C:\Windows\System32\drivers\etc\hosts" | |
| with open(hosts_path, "r") as f: | |
| for line in f: | |
| line = line.split("#", 1)[0].strip() | |
| parts = line.split() | |
| if len(parts) == 2: | |
| host = parts[1] | |
| missing_hosts.discard(host) | |
| if missing_hosts: | |
| raise WptrunError("""Missing hosts file configuration. Expected entries like: | |
| %s | |
| See README.md for more details.""" % "\n".join("%s\t%s" % | |
| ("127.0.0.1" if "nonexistent" not in host else "0.0.0.0", host) | |
| for host in expected_hosts)) | |
| class BrowserSetup(object): | |
| name = None | |
| browser_cls = None | |
| def __init__(self, venv, prompt=True, sub_product=None): | |
| self.browser = self.browser_cls() | |
| self.venv = venv | |
| self.prompt = prompt | |
| self.sub_product = sub_product | |
| def prompt_install(self, component): | |
| if not self.prompt: | |
| return True | |
| while True: | |
| resp = raw_input("Download and install %s [Y/n]? " % component).strip().lower() | |
| if not resp or resp == "y": | |
| return True | |
| elif resp == "n": | |
| return False | |
| def install(self, venv): | |
| if self.prompt_install(self.name): | |
| return self.browser.install(venv.path) | |
| def setup(self, kwargs): | |
| self.venv.install_requirements(os.path.join(wpt_root, "tools", "wptrunner", self.browser.requirements)) | |
| self.setup_kwargs(kwargs) | |
| class Firefox(BrowserSetup): | |
| name = "firefox" | |
| browser_cls = browser.Firefox | |
| def setup_kwargs(self, kwargs): | |
| if kwargs["binary"] is None: | |
| binary = self.browser.find_binary() | |
| if binary is None: | |
| raise WptrunError("""Firefox binary not found on $PATH. | |
| Install Firefox or use --binary to set the binary path""") | |
| kwargs["binary"] = binary | |
| if kwargs["certutil_binary"] is None and kwargs["ssl_type"] != "none": | |
| certutil = self.browser.find_certutil() | |
| if certutil is None: | |
| # Can't download this for now because it's missing the libnss3 library | |
| raise WptrunError("""Can't find certutil. | |
| This must be installed using your OS package manager or directly e.g. | |
| Debian/Ubuntu: | |
| sudo apt install libnss3-tools | |
| macOS/Homebrew: | |
| brew install nss | |
| Others: | |
| Download the firefox archive and common.tests.zip archive for your platform | |
| from https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central/ | |
| Then extract certutil[.exe] from the tests.zip package and | |
| libnss3[.so|.dll|.dynlib] and but the former on your path and the latter on | |
| your library path. | |
| """) | |
| else: | |
| print("Using certutil %s" % certutil) | |
| if certutil is not None: | |
| kwargs["certutil_binary"] = certutil | |
| else: | |
| print("Unable to find or install certutil, setting ssl-type to none") | |
| kwargs["ssl_type"] = "none" | |
| if kwargs["webdriver_binary"] is None and "wdspec" in kwargs["test_types"]: | |
| webdriver_binary = self.browser.find_webdriver() | |
| if webdriver_binary is None: | |
| install = self.prompt_install("geckodriver") | |
| if install: | |
| print("Downloading geckodriver") | |
| webdriver_binary = self.browser.install_webdriver(dest=self.venv.bin_path) | |
| else: | |
| print("Using webdriver binary %s" % webdriver_binary) | |
| if webdriver_binary: | |
| kwargs["webdriver_binary"] = webdriver_binary | |
| else: | |
| print("Unable to find or install geckodriver, skipping wdspec tests") | |
| kwargs["test_types"].remove("wdspec") | |
| if kwargs["prefs_root"] is None: | |
| print("Downloading gecko prefs") | |
| prefs_root = self.browser.install_prefs(self.venv.path) | |
| kwargs["prefs_root"] = prefs_root | |
| class Chrome(BrowserSetup): | |
| name = "chrome" | |
| browser_cls = browser.Chrome | |
| def setup_kwargs(self, kwargs): | |
| if kwargs["webdriver_binary"] is None: | |
| webdriver_binary = self.browser.find_webdriver() | |
| if webdriver_binary is None: | |
| install = self.prompt_install("chromedriver") | |
| if install: | |
| print("Downloading chromedriver") | |
| webdriver_binary = self.browser.install_webdriver(dest=self.venv.bin_path) | |
| else: | |
| print("Using webdriver binary %s" % webdriver_binary) | |
| if webdriver_binary: | |
| kwargs["webdriver_binary"] = webdriver_binary | |
| else: | |
| raise WptrunError("Unable to locate or install chromedriver binary") | |
| class Edge(BrowserSetup): | |
| name = "edge" | |
| browser_cls = browser.Edge | |
| def install(self, venv): | |
| raise NotImplementedError | |
| def setup_kwargs(self, kwargs): | |
| if kwargs["webdriver_binary"] is None: | |
| webdriver_binary = self.browser.find_webdriver() | |
| if webdriver_binary is None: | |
| raise WptrunError("""Unable to find WebDriver and we aren't yet clever enough to work out which | |
| version to download. Please go to the following URL and install the correct | |
| version for your Edge/Windows release somewhere on the %PATH%: | |
| https://developer.microsoft.com/en-us/microsoft-edge/tools/webdriver/ | |
| """) | |
| kwargs["webdriver_binary"] = webdriver_binary | |
| class Sauce(BrowserSetup): | |
| name = "sauce" | |
| browser_cls = browser.Sauce | |
| def install(self, venv): | |
| raise NotImplementedError | |
| def setup_kwargs(self, kwargs): | |
| kwargs.set_if_none("sauce_browser", self.sub_product[0]) | |
| kwargs.set_if_none("sauce_version", self.sub_product[1]) | |
| kwargs["test_types"] = ["testharness", "reftest"] | |
| class Servo(BrowserSetup): | |
| name = "servo" | |
| browser_cls = browser.Servo | |
| def install(self, venv): | |
| raise NotImplementedError | |
| def setup_kwargs(self, kwargs): | |
| if kwargs["binary"] is None: | |
| binary = self.browser.find_binary() | |
| if binary is None: | |
| raise WptrunError("Unable to find servo binary on the PATH") | |
| kwargs["binary"] = binary | |
| product_setup = { | |
| "firefox": Firefox, | |
| "chrome": Chrome, | |
| "edge": Edge, | |
| "servo": Servo, | |
| "sauce": Sauce, | |
| } | |
| def setup_wptrunner(venv, prompt=True, install=False, **kwargs): | |
| from wptrunner import wptrunner, wptcommandline | |
| global logger | |
| kwargs = utils.Kwargs(kwargs.iteritems()) | |
| product_parts = kwargs["product"].split(":") | |
| kwargs["product"] = product_parts[0] | |
| sub_product = product_parts[1:] | |
| wptrunner.setup_logging(kwargs, {"mach": sys.stdout}) | |
| logger = wptrunner.logger | |
| check_environ(kwargs["product"]) | |
| args_general(kwargs) | |
| if kwargs["product"] not in product_setup: | |
| raise WptrunError("Unsupported product %s" % kwargs["product"]) | |
| setup_cls = product_setup[kwargs["product"]](venv, prompt, sub_product) | |
| if install: | |
| logger.info("Installing browser") | |
| kwargs["binary"] = setup_cls.install(venv) | |
| setup_cls.setup(kwargs) | |
| wptcommandline.check_args(kwargs) | |
| wptrunner_path = os.path.join(wpt_root, "tools", "wptrunner") | |
| venv.install_requirements(os.path.join(wptrunner_path, "requirements.txt")) | |
| return kwargs | |
| def run(venv, **kwargs): | |
| #Remove arguments that aren't passed to wptrunner | |
| prompt = kwargs.pop("prompt", True) | |
| stability = kwargs.pop("stability", True) | |
| install_browser = kwargs.pop("install_browser", False) | |
| kwargs = setup_wptrunner(venv, | |
| prompt=prompt, | |
| install=install_browser, | |
| **kwargs) | |
| if stability: | |
| import stability | |
| iterations, results, inconsistent = stability.run(venv, logger, **kwargs) | |
| def log(x): | |
| print(x) | |
| if inconsistent: | |
| stability.write_inconsistent(log, inconsistent, iterations) | |
| else: | |
| log("All tests stable") | |
| rv = len(inconsistent) > 0 | |
| else: | |
| rv = run_single(venv, **kwargs) > 0 | |
| return rv | |
| def run_single(venv, **kwargs): | |
| from wptrunner import wptrunner | |
| return wptrunner.start(**kwargs) | |
| def main(): | |
| try: | |
| parser = create_parser() | |
| args = parser.parse_args() | |
| venv = virtualenv.Virtualenv(os.path.join(wpt_root, "_venv_%s") % platform.uname()[0]) | |
| venv.start() | |
| venv.install_requirements(os.path.join(wpt_root, "tools", "wptrunner", "requirements.txt")) | |
| venv.install("requests") | |
| return run(venv, vars(args)) | |
| except WptrunError as e: | |
| exit(e.message) | |
| if __name__ == "__main__": | |
| import pdb | |
| from tools import localpaths | |
| try: | |
| main() | |
| except: | |
| pdb.post_mortem() |