Import Cobalt 20.master.0.215766
diff --git a/src/third_party/web_platform_tests/tools/wpt/__init__.py b/src/third_party/web_platform_tests/tools/wpt/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/__init__.py
diff --git a/src/third_party/web_platform_tests/tools/wpt/browser.py b/src/third_party/web_platform_tests/tools/wpt/browser.py
new file mode 100644
index 0000000..ebfada0
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/browser.py
@@ -0,0 +1,351 @@
+import logging
+import os
+import platform
+import re
+import stat
+from abc import ABCMeta, abstractmethod
+from ConfigParser import RawConfigParser
+from distutils.spawn import find_executable
+
+from utils import call, get, untar, unzip
+
+logger = logging.getLogger(__name__)
+
+uname = platform.uname()
+
+def path(path, exe):
+ path = path.replace("/", os.path.sep)
+ if exe and uname[0] == "Windows":
+ path += ".exe"
+ return path
+
+
+class Browser(object):
+ __metaclass__ = ABCMeta
+
+ @abstractmethod
+ def install(self, dest=None):
+ return NotImplemented
+
+ @abstractmethod
+ def install_webdriver(self):
+ return NotImplemented
+
+ @abstractmethod
+ def version(self):
+ return NotImplemented
+
+ @abstractmethod
+ def requirements(self):
+ """Name of the browser-specific wptrunner requirements file"""
+ return NotImplemented
+
+ def prepare_environment(self):
+ """Do any additional setup of the environment required to start the
+ browser successfully
+ """
+ pass
+
+
+class Firefox(Browser):
+ """Firefox-specific interface.
+
+ Includes installation, webdriver installation, and wptrunner setup methods.
+ """
+
+ product = "firefox"
+ binary = "firefox/firefox"
+ platform_ini = "firefox/platform.ini"
+ requirements = "requirements_firefox.txt"
+
+
+ def platform_string(self):
+ platform = {
+ "Linux": "linux",
+ "Windows": "win",
+ "Darwin": "mac"
+ }.get(uname[0])
+
+ if platform is None:
+ raise ValueError("Unable to construct a valid Firefox package name for current platform")
+
+ if platform == "linux":
+ bits = "-%s" % uname[-1]
+ elif platform == "win":
+ bits = "64" if uname[-1] == "x86_64" else "32"
+ else:
+ bits = ""
+
+ return "%s%s" % (platform, bits)
+
+ def platform_string_geckodriver(self):
+ platform = {
+ "Linux": "linux",
+ "Windows": "win",
+ "Darwin": "macos"
+ }.get(uname[0])
+
+ if platform is None:
+ raise ValueError("Unable to construct a valid Geckodriver package name for current platform")
+
+ if platform in ("linux", "win"):
+ bits = "64" if uname[-1] == "x86_64" else "32"
+ else:
+ bits = ""
+
+ return "%s%s" % (platform, bits)
+
+ def latest_nightly_listing(self):
+ return get("https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central/")
+
+ def get_from_nightly(self, pattern):
+ index = self.latest_nightly_listing()
+ filename = re.compile(pattern).search(index.text).group(1)
+ return get("https://archive.mozilla.org/pub/firefox/nightly/latest-mozilla-central/%s" %
+ filename)
+
+ def install(self, dest=None):
+ """Install Firefox."""
+ if dest is None:
+ dest = os.getcwd()
+
+ resp = self.get_from_nightly("<a[^>]*>(firefox-\d+\.\d(?:\w\d)?.en-US.%s\.tar\.bz2)" % self.platform_string())
+ untar(resp.raw, dest=dest)
+ return find_executable("firefox", os.path.join(dest, "firefox"))
+
+ def find_binary(self, path=None):
+ return find_executable("firefox", path)
+
+ def find_certutil(self):
+ path = find_executable("certutil")
+ if path is None:
+ return None
+ if os.path.splitdrive(path)[1].split(os.path.sep) == ["", "Windows", "system32", "certutil.exe"]:
+ return None
+ return path
+
+ def find_webdriver(self):
+ return find_executable("geckodriver")
+
+ def install_certutil(self, dest=None):
+ # TODO: this doesn't really work because it just gets the binary, and is missing the
+ # libnss3 library. Getting that means either downloading the corresponding Firefox
+ # and extracting the library (which is hard on mac becase DMG), or maybe downloading from
+ # nss's treeherder builds?
+ if dest is None:
+ dest = os.pwd
+
+ # Don't create a path like bin/bin/certutil
+ split = os.path.split(dest)
+ if split[1] == "bin":
+ dest = split[0]
+
+ resp = self.get_from_nightly(
+ "<a[^>]*>(firefox-\d+\.\d(?:\w\d)?.en-US.%s\.common\.tests.zip)</a>" % self.platform_string())
+ bin_path = path("bin/certutil", exe=True)
+ unzip(resp.raw, dest=dest, limit=[bin_path])
+
+ return os.path.join(dest, bin_path)
+
+ def install_prefs(self, dest=None):
+ if dest is None:
+ dest = os.pwd
+
+ dest = os.path.join(dest, "profiles")
+ if not os.path.exists(dest):
+ os.makedirs(dest)
+ with open(os.path.join(dest, "prefs_general.js"), "wb") as f:
+ resp = get("https://hg.mozilla.org/mozilla-central/raw-file/tip/testing/profiles/prefs_general.js")
+ f.write(resp.content)
+
+ return dest
+
+ def _latest_geckodriver_version(self):
+ """Get and return latest version number for geckodriver."""
+ # This is used rather than an API call to avoid rate limits
+ tags = call("git", "ls-remote", "--tags", "--refs",
+ "https://github.com/mozilla/geckodriver.git")
+ release_re = re.compile(".*refs/tags/v(\d+)\.(\d+)\.(\d+)")
+ latest_release = 0
+ for item in tags.split("\n"):
+ m = release_re.match(item)
+ if m:
+ version = [int(item) for item in m.groups()]
+ if version > latest_release:
+ latest_release = version
+ assert latest_release != 0
+ return "v%s.%s.%s" % tuple(str(item) for item in latest_release)
+
+ def install_webdriver(self, dest=None):
+ """Install latest Geckodriver."""
+ if dest is None:
+ dest = os.getcwd()
+
+ version = self._latest_geckodriver_version()
+ format = "zip" if uname[0] == "Windows" else "tar.gz"
+ logger.debug("Latest geckodriver release %s" % version)
+ url = ("https://github.com/mozilla/geckodriver/releases/download/%s/geckodriver-%s-%s.%s" %
+ (version, version, self.platform_string_geckodriver(), format))
+ if format == "zip":
+ unzip(get(url).raw, dest=dest)
+ else:
+ untar(get(url).raw, dest=dest)
+ return find_executable(os.path.join(dest, "geckodriver"))
+
+ def version(self, root):
+ """Retrieve the release version of the installed browser."""
+ platform_info = RawConfigParser()
+
+ with open(os.path.join(root, self.platform_ini), "r") as fp:
+ platform_info.readfp(BytesIO(fp.read()))
+ return "BuildID %s; SourceStamp %s" % (
+ platform_info.get("Build", "BuildID"),
+ platform_info.get("Build", "SourceStamp"))
+
+
+class Chrome(Browser):
+ """Chrome-specific interface.
+
+ Includes installation, webdriver installation, and wptrunner setup methods.
+ """
+
+ product = "chrome"
+ binary = "/usr/bin/google-chrome"
+ requirements = "requirements_chrome.txt"
+
+ def install(self, dest=None):
+ raise NotImplementedError
+
+ def platform_string(self):
+ platform = {
+ "Linux": "linux",
+ "Windows": "win",
+ "Darwin": "mac"
+ }.get(uname[0])
+
+ if platform is None:
+ raise ValueError("Unable to construct a valid Chrome package name for current platform")
+
+ if platform == "linux":
+ bits = "64" if uname[-1] == "x86_64" else "32"
+ elif platform == "mac":
+ bits = "64"
+ elif platform == "win":
+ bits = "32"
+
+ return "%s%s" % (platform, bits)
+
+ def find_webdriver(self):
+ return find_executable("chromedriver")
+
+ def install_webdriver(self, dest=None):
+ """Install latest Webdriver."""
+ if dest is None:
+ dest = os.pwd
+ latest = get("http://chromedriver.storage.googleapis.com/LATEST_RELEASE").text.strip()
+ url = "http://chromedriver.storage.googleapis.com/%s/chromedriver_%s.zip" % (latest,
+ self.platform_string())
+ unzip(get(url).raw, dest)
+
+ path = find_executable("chromedriver", dest)
+ st = os.stat(path)
+ os.chmod(path, st.st_mode | stat.S_IEXEC)
+ return path
+
+ def version(self, root):
+ """Retrieve the release version of the installed browser."""
+ output = call(self.binary, "--version")
+ return re.search(r"[0-9\.]+( [a-z]+)?$", output.strip()).group(0)
+
+ def prepare_environment(self):
+ # https://bugs.chromium.org/p/chromium/issues/detail?id=713947
+ logger.debug("DBUS_SESSION_BUS_ADDRESS %s" % os.environ.get("DBUS_SESSION_BUS_ADDRESS"))
+ if "DBUS_SESSION_BUS_ADDRESS" not in os.environ:
+ if find_executable("dbus-launch"):
+ logger.debug("Attempting to start dbus")
+ dbus_conf = subprocess.check_output(["dbus-launch"])
+ logger.debug(dbus_conf)
+
+ # From dbus-launch(1):
+ #
+ # > When dbus-launch prints bus information to standard output,
+ # > by default it is in a simple key-value pairs format.
+ for line in dbus_conf.strip().split("\n"):
+ key, _, value = line.partition("=")
+ os.environ[key] = value
+ else:
+ logger.critical("dbus not running and can't be started")
+ sys.exit(1)
+
+
+class Edge(Browser):
+ """Edge-specific interface.
+
+ Includes installation, webdriver installation, and wptrunner setup methods.
+ """
+
+ product = "edge"
+ requirements = "requirements_edge.txt"
+
+ def install(self, dest=None):
+ raise NotImplementedError
+
+ def find_webdriver(self):
+ return find_executable("MicrosoftWebDriver")
+
+ def install_webdriver(self, dest=None):
+ """Install latest Webdriver."""
+ raise NotImplementedError
+
+ def version(self):
+ raise NotImplementedError
+
+
+class Servo(Browser):
+ """Servo-specific interface.
+
+ Includes installation, webdriver installation, and wptrunner setup methods.
+ """
+
+ product = "servo"
+ requirements = "requirements_servo.txt"
+
+ def install(self, dest=None):
+ raise NotImplementedError
+
+ def find_binary(self, path=None):
+ return find_executable("servo")
+
+ def find_webdriver(self):
+ return None
+
+ def install_webdriver(self):
+ raise NotImplementedError
+
+ def version(self, root):
+ return None
+
+
+class Sauce(Browser):
+ """Sauce-specific interface.
+
+ Includes installation, webdriver installation, and wptrunner setup methods.
+ """
+
+ product = "sauce"
+ requirements = "requirements_sauce.txt"
+
+ def install(self, dest=None):
+ raise NotImplementedError
+
+ def find_binary(self, path=None):
+ return None
+
+ def find_webdriver(self):
+ return None
+
+ def install_webdriver(self):
+ raise NotImplementedError
+
+ def version(self, root):
+ return None
diff --git a/src/third_party/web_platform_tests/tools/wpt/commands.json b/src/third_party/web_platform_tests/tools/wpt/commands.json
new file mode 100644
index 0000000..1ab767f
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/commands.json
@@ -0,0 +1,9 @@
+{
+ "run": {"path": "run.py", "script": "run", "parser": "create_parser", "help": "Run tests in a browser",
+ "virtualenv": true, "install": ["requests"], "requirements": ["../wptrunner/requirements.txt"]},
+ "files-changed": {"path": "testfiles.py", "script": "run_changed_files", "parser": "get_parser",
+ "help": "Get a list of files that have changed", "virtualenv": false},
+ "tests-affected": {"path": "testfiles.py", "script": "run_tests_affected", "parser": "get_parser_affected",
+ "help": "Get a list of tests affected by changes", "virtualenv": false},
+ "install": {"path": "install.py", "script": "run", "parser": "get_parser", "help": "Install browser components"}
+}
diff --git a/src/third_party/web_platform_tests/tools/wpt/install.py b/src/third_party/web_platform_tests/tools/wpt/install.py
new file mode 100644
index 0000000..408744a
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/install.py
@@ -0,0 +1,46 @@
+import argparse
+import browser
+import sys
+
+def get_parser():
+ parser = argparse.ArgumentParser()
+ parser.add_argument('browser', choices=['firefox', 'chrome'],
+ help='name of web browser product')
+ parser.add_argument('component', choices=['browser', 'webdriver'],
+ help='name of component')
+ parser.add_argument('-d', '--destination',
+ help='filesystem directory to place the component')
+ return parser
+
+
+def run(venv, **kwargs):
+ browser = kwargs["browser"]
+ destination = kwargs["destination"]
+
+ if destination is None:
+ if venv:
+ if kwargs["component"] == "browser":
+ destination = venv.path
+ else:
+ destination = venv.bin_path
+ else:
+ raise argparse.ArgumentError(None,
+ "No --destination argument, and no default for the environment")
+
+ install(browser, kwargs["component"], destination)
+
+
+def install(name, component, destination):
+ if component == 'webdriver':
+ method = 'install_webdriver'
+ else:
+ method = 'install'
+
+ subclass = getattr(browser, name.title())
+ sys.stdout.write('Now installing %s %s...\n' % (name, component))
+ getattr(subclass(), method)(dest=destination)
+
+
+if __name__ == '__main__':
+ args = parser.parse_args()
+ run(None, **vars(args))
diff --git a/src/third_party/web_platform_tests/tools/wpt/markdown.py b/src/third_party/web_platform_tests/tools/wpt/markdown.py
new file mode 100644
index 0000000..8701891
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/markdown.py
@@ -0,0 +1,55 @@
+def format_comment_title(product):
+ """Produce a Markdown-formatted string based on a given "product"--a string
+ containing a browser identifier optionally followed by a colon and a
+ release channel. (For example: "firefox" or "chrome:dev".) The generated
+ title string is used both to create new comments and to locate (and
+ subsequently update) previously-submitted comments."""
+ parts = product.split(":")
+ title = parts[0].title()
+
+ if len(parts) > 1:
+ title += " (%s)" % parts[1]
+
+ return "# %s #" % title
+
+
+def markdown_adjust(s):
+ """Escape problematic markdown sequences."""
+ s = s.replace('\t', u'\\t')
+ s = s.replace('\n', u'\\n')
+ s = s.replace('\r', u'\\r')
+ s = s.replace('`', u'')
+ s = s.replace('|', u'\\|')
+ return s
+
+
+def table(headings, data, log):
+ """Create and log data to specified logger in tabular format."""
+ cols = range(len(headings))
+ assert all(len(item) == len(cols) for item in data)
+ max_widths = reduce(lambda prev, cur: [(len(cur[i]) + 2)
+ if (len(cur[i]) + 2) > prev[i]
+ else prev[i]
+ for i in cols],
+ data,
+ [len(item) + 2 for item in headings])
+ log("|%s|" % "|".join(item.center(max_widths[i]) for i, item in enumerate(headings)))
+ log("|%s|" % "|".join("-" * max_widths[i] for i in cols))
+ for row in data:
+ log("|%s|" % "|".join(" %s" % row[i].ljust(max_widths[i] - 1) for i in cols))
+ log("")
+
+
+def err_string(results_dict, iterations):
+ """Create and return string with errors from test run."""
+ rv = []
+ total_results = sum(results_dict.values())
+ for key, value in sorted(results_dict.items()):
+ rv.append("%s%s" %
+ (key, ": %s/%s" % (value, iterations) if value != iterations else ""))
+ if total_results < iterations:
+ rv.append("MISSING: %s/%s" % (iterations - total_results, iterations))
+ rv = ", ".join(rv)
+ if is_inconsistent(results_dict, iterations):
+ rv = "**%s**" % rv
+ return rv
diff --git a/src/third_party/web_platform_tests/tools/wpt/paths b/src/third_party/web_platform_tests/tools/wpt/paths
new file mode 100644
index 0000000..0ef13c9
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/paths
@@ -0,0 +1,5 @@
+tools/ci/
+tools/lint/
+tools/manifest/
+tools/serve/
+tools/wpt/
diff --git a/src/third_party/web_platform_tests/tools/wpt/requirements.txt b/src/third_party/web_platform_tests/tools/wpt/requirements.txt
new file mode 100644
index 0000000..7369cb8
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/requirements.txt
@@ -0,0 +1 @@
+requests==2.14.2
diff --git a/src/third_party/web_platform_tests/tools/wpt/run.py b/src/third_party/web_platform_tests/tools/wpt/run.py
new file mode 100644
index 0000000..a7cd48d
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/run.py
@@ -0,0 +1,387 @@
+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()
diff --git a/src/third_party/web_platform_tests/tools/wpt/stability.py b/src/third_party/web_platform_tests/tools/wpt/stability.py
new file mode 100644
index 0000000..b3c8570
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/stability.py
@@ -0,0 +1,195 @@
+import os
+import sys
+from collections import OrderedDict, defaultdict
+
+from mozlog import reader
+from mozlog.formatters import JSONFormatter, TbplFormatter
+from mozlog.handlers import BaseHandler, LogLevelFilter, StreamHandler
+
+from markdown import markdown_adjust, table
+from wptrunner import wptrunner
+
+
+class LogActionFilter(BaseHandler):
+
+ """Handler that filters out messages not of a given set of actions.
+
+ Subclasses BaseHandler.
+
+ :param inner: Handler to use for messages that pass this filter
+ :param actions: List of actions for which to fire the handler
+ """
+
+ def __init__(self, inner, actions):
+ """Extend BaseHandler and set inner and actions props on self."""
+ BaseHandler.__init__(self, inner)
+ self.inner = inner
+ self.actions = actions
+
+ def __call__(self, item):
+ """Invoke handler if action is in list passed as constructor param."""
+ if item["action"] in self.actions:
+ return self.inner(item)
+
+
+class LogHandler(reader.LogHandler):
+
+ """Handle updating test and subtest status in log.
+
+ Subclasses reader.LogHandler.
+ """
+ def __init__(self):
+ self.results = OrderedDict()
+
+ def find_or_create_test(self, data):
+ test_name = data["test"]
+ if self.results.get(test_name):
+ return self.results[test_name]
+
+ test = {
+ "subtests": OrderedDict(),
+ "status": defaultdict(int)
+ }
+ self.results[test_name] = test
+ return test
+
+ def find_or_create_subtest(self, data):
+ test = self.find_or_create_test(data)
+ subtest_name = data["subtest"]
+
+ if test["subtests"].get(subtest_name):
+ return test["subtests"][subtest_name]
+
+ subtest = {
+ "status": defaultdict(int),
+ "messages": set()
+ }
+ test["subtests"][subtest_name] = subtest
+
+ return subtest
+
+ def test_status(self, data):
+ subtest = self.find_or_create_subtest(data)
+ subtest["status"][data["status"]] += 1
+ if data.get("message"):
+ subtest["messages"].add(data["message"])
+
+ def test_end(self, data):
+ test = self.find_or_create_test(data)
+ test["status"][data["status"]] += 1
+
+
+def is_inconsistent(results_dict, iterations):
+ """Return whether or not a single test is inconsistent."""
+ return len(results_dict) > 1 or sum(results_dict.values()) != iterations
+
+
+def process_results(log, iterations):
+ """Process test log and return overall results and list of inconsistent tests."""
+ inconsistent = []
+ handler = LogHandler()
+ reader.handle_log(reader.read(log), handler)
+ results = handler.results
+ for test_name, test in results.iteritems():
+ if is_inconsistent(test["status"], iterations):
+ inconsistent.append((test_name, None, test["status"], []))
+ for subtest_name, subtest in test["subtests"].iteritems():
+ if is_inconsistent(subtest["status"], iterations):
+ inconsistent.append((test_name, subtest_name, subtest["status"], subtest["messages"]))
+ return results, inconsistent
+
+
+def err_string(results_dict, iterations):
+ """Create and return string with errors from test run."""
+ rv = []
+ total_results = sum(results_dict.values())
+ for key, value in sorted(results_dict.items()):
+ rv.append("%s%s" %
+ (key, ": %s/%s" % (value, iterations) if value != iterations else ""))
+ if total_results < iterations:
+ rv.append("MISSING: %s/%s" % (iterations - total_results, iterations))
+ rv = ", ".join(rv)
+ if is_inconsistent(results_dict, iterations):
+ rv = "**%s**" % rv
+ return rv
+
+
+def write_inconsistent(log, inconsistent, iterations):
+ """Output inconsistent tests to logger.error."""
+ log("## Unstable results ##\n")
+ strings = [(
+ "`%s`" % markdown_adjust(test),
+ ("`%s`" % markdown_adjust(subtest)) if subtest else "",
+ err_string(results, iterations),
+ ("`%s`" % markdown_adjust(";".join(messages))) if len(messages) else "")
+ for test, subtest, results, messages in inconsistent]
+ table(["Test", "Subtest", "Results", "Messages"], strings, log)
+
+
+def write_results(log, results, iterations, pr_number=None, use_details=False):
+ log("## All results ##\n")
+ if use_details:
+ log("<details>\n")
+ log("<summary>%i %s ran</summary>\n\n" % (len(results),
+ "tests" if len(results) > 1
+ else "test"))
+
+ for test_name, test in results.iteritems():
+ baseurl = "http://w3c-test.org/submissions"
+ if "https" in os.path.splitext(test_name)[0].split(".")[1:]:
+ baseurl = "https://w3c-test.org/submissions"
+ title = test_name
+ if use_details:
+ log("<details>\n")
+ if pr_number:
+ title = "<a href=\"%s/%s%s\">%s</a>" % (baseurl, pr_number, test_name, title)
+ log('<summary>%s</summary>\n\n' % title)
+ else:
+ log("### %s ###" % title)
+ strings = [("", err_string(test["status"], iterations), "")]
+
+ strings.extend(((
+ ("`%s`" % markdown_adjust(subtest_name)) if subtest else "",
+ err_string(subtest["status"], iterations),
+ ("`%s`" % markdown_adjust(';'.join(subtest["messages"]))) if len(subtest["messages"]) else "")
+ for subtest_name, subtest in test["subtests"].items()))
+ table(["Subtest", "Results", "Messages"], strings, log)
+ if use_details:
+ log("</details>\n")
+
+ if use_details:
+ log("</details>\n")
+
+
+def run(venv, logger, **kwargs):
+ kwargs["pause_after_test"] = False
+ if kwargs["repeat"] == 1:
+ kwargs["repeat"] = 10
+
+ handler = LogActionFilter(
+ LogLevelFilter(
+ StreamHandler(
+ sys.stdout,
+ TbplFormatter()
+ ),
+ "WARNING"),
+ ["log", "process_output"])
+
+ # There is a public API for this in the next mozlog
+ initial_handlers = logger._state.handlers
+ logger._state.handlers = []
+
+ with open("raw.log", "wb") as log:
+ # Setup logging for wptrunner that keeps process output and
+ # warning+ level logs only
+ logger.add_handler(handler)
+ logger.add_handler(StreamHandler(log, JSONFormatter()))
+
+ wptrunner.run_tests(**kwargs)
+
+ logger._state.handlers = initial_handlers
+
+ with open("raw.log", "rb") as log:
+ results, inconsistent = process_results(log, kwargs["repeat"])
+
+ return kwargs["repeat"], results, inconsistent
diff --git a/src/third_party/web_platform_tests/tools/wpt/testfiles.py b/src/third_party/web_platform_tests/tools/wpt/testfiles.py
new file mode 100644
index 0000000..89e6e27
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/testfiles.py
@@ -0,0 +1,286 @@
+import argparse
+import itertools
+import logging
+import os
+import subprocess
+import sys
+
+from ..manifest import manifest, update
+
+here = os.path.dirname(__file__)
+wpt_root = os.path.abspath(os.path.join(here, os.pardir, os.pardir))
+
+logger = logging.getLogger()
+
+
+def get_git_cmd(repo_path):
+ """Create a function for invoking git commands as a subprocess."""
+ def git(cmd, *args):
+ full_cmd = ["git", cmd] + list(item.decode("utf8") if isinstance(item, bytes) else item for item in args)
+ try:
+ logger.debug(" ".join(full_cmd))
+ return subprocess.check_output(full_cmd, cwd=repo_path, stderr=subprocess.STDOUT).decode("utf8").strip()
+ except subprocess.CalledProcessError as e:
+ logger.error("Git command exited with status %i" % e.returncode)
+ logger.error(e.output)
+ sys.exit(1)
+ return git
+
+
+def branch_point():
+ git = get_git_cmd(wpt_root)
+ if os.environ.get("TRAVIS_PULL_REQUEST", "false") != "false":
+ # This is a PR, so the base branch is in TRAVIS_BRANCH
+ travis_branch = os.environ.get("TRAVIS_BRANCH")
+ assert travis_branch, "TRAVIS_BRANCH environment variable is defined"
+ branch_point = git("rev-parse", travis_branch)
+ else:
+ # Otherwise we aren't on a PR, so we try to find commits that are only in the
+ # current branch c.f.
+ # http://stackoverflow.com/questions/13460152/find-first-ancestor-commit-in-another-branch
+ head = git("rev-parse", "HEAD")
+ not_heads = [item for item in git("rev-parse", "--not", "--all").split("\n")
+ if item.strip() and head not in item]
+ commits = git("rev-list", "HEAD", *not_heads).split("\n")
+ branch_point = None
+ if len(commits):
+ first_commit = commits[-1]
+ if first_commit:
+ branch_point = git("rev-parse", first_commit + "^")
+
+ # The above heuristic will fail in the following cases:
+ #
+ # - The current branch has fallen behind the version retrieved via the above
+ # `fetch` invocation
+ # - Changes on the current branch were rebased and therefore do not exist on any
+ # other branch. This will result in the selection of a commit that is earlier
+ # in the history than desired (as determined by calculating the later of the
+ # branch point and the merge base)
+ #
+ # In either case, fall back to using the merge base as the branch point.
+ merge_base = git("merge-base", "HEAD", "origin/master")
+ if (branch_point is None or
+ (branch_point != merge_base and
+ not git("log", "--oneline", "%s..%s" % (merge_base, branch_point)).strip())):
+ logger.debug("Using merge-base as the branch point")
+ branch_point = merge_base
+ else:
+ logger.debug("Using first commit on another branch as the branch point")
+
+ logger.debug("Branch point from master: %s" % branch_point)
+ return branch_point
+
+
+def files_changed(revish, ignore_dirs=None, include_uncommitted=False, include_new=False):
+ """Get and return files changed since current branch diverged from master,
+ excluding those that are located within any directory specifed by
+ `ignore_changes`."""
+ if ignore_dirs is None:
+ ignore_dirs = []
+
+ git = get_git_cmd(wpt_root)
+ files = git("diff", "--name-only", "-z", revish).split("\0")
+ assert not files[-1]
+ files = set(files[:-1])
+
+ if include_uncommitted:
+ entries = git("status", "-z").split("\0")
+ assert not entries[-1]
+ entries = entries[:-1]
+ for item in entries:
+ status, path = item.split()
+ if status == "??" and not include_new:
+ continue
+ else:
+ if not os.path.isdir(path):
+ files.add(path)
+ else:
+ for dirpath, dirnames, filenames in os.walk(path):
+ for filename in filenames:
+ files.add(os.path.join(dirpath, filename))
+
+ if not files:
+ return [], []
+
+ changed = []
+ ignored = []
+ for item in sorted(files):
+ fullpath = os.path.join(wpt_root, item)
+ topmost_dir = item.split(os.sep, 1)[0]
+ if topmost_dir in ignore_dirs:
+ ignored.append(fullpath)
+ else:
+ changed.append(fullpath)
+
+ return changed, ignored
+
+
+def _in_repo_root(full_path):
+ rel_path = os.path.relpath(full_path, wpt_root)
+ path_components = rel_path.split(os.sep)
+ return len(path_components) < 2
+
+def _init_manifest_cache():
+ c = {}
+
+ def load(manifest_path=None):
+ if manifest_path is None:
+ manifest_path = os.path.join(wpt_root, "MANIFEST.json")
+ if c.get(manifest_path):
+ return c[manifest_path]
+ # cache at most one path:manifest
+ c.clear()
+ wpt_manifest = manifest.load(wpt_root, manifest_path)
+ if wpt_manifest is None:
+ wpt_manifest = manifest.Manifest()
+ update.update(wpt_root, wpt_manifest)
+ c[manifest_path] = wpt_manifest
+ return c[manifest_path]
+ return load
+
+load_manifest = _init_manifest_cache()
+
+
+def affected_testfiles(files_changed, skip_tests, manifest_path=None):
+ """Determine and return list of test files that reference changed files."""
+ affected_testfiles = set()
+ # Exclude files that are in the repo root, because
+ # they are not part of any test.
+ files_changed = [f for f in files_changed if not _in_repo_root(f)]
+ nontests_changed = set(files_changed)
+ wpt_manifest = load_manifest(manifest_path)
+
+ test_types = ["testharness", "reftest", "wdspec"]
+ support_files = {os.path.join(wpt_root, path)
+ for _, path, _ in wpt_manifest.itertypes("support")}
+ wdspec_test_files = {os.path.join(wpt_root, path)
+ for _, path, _ in wpt_manifest.itertypes("wdspec")}
+ test_files = {os.path.join(wpt_root, path)
+ for _, path, _ in wpt_manifest.itertypes(*test_types)}
+
+ nontests_changed = nontests_changed.intersection(support_files)
+
+ tests_changed = set(item for item in files_changed if item in test_files)
+
+ nontest_changed_paths = set()
+ for full_path in nontests_changed:
+ rel_path = os.path.relpath(full_path, wpt_root)
+ path_components = rel_path.split(os.sep)
+ top_level_subdir = path_components[0]
+ if top_level_subdir in skip_tests:
+ continue
+ repo_path = "/" + os.path.relpath(full_path, wpt_root).replace(os.path.sep, "/")
+ nontest_changed_paths.add((full_path, repo_path))
+
+ def affected_by_wdspec(test):
+ affected = False
+ if test in wdspec_test_files:
+ for support_full_path, _ in nontest_changed_paths:
+ # parent of support file or of "support" directory
+ parent = os.path.dirname(support_full_path)
+ if os.path.basename(parent) == "support":
+ parent = os.path.dirname(parent)
+ relpath = os.path.relpath(test, parent)
+ if not relpath.startswith(os.pardir):
+ # testfile is in subtree of support file
+ affected = True
+ break
+ return affected
+
+ for root, dirs, fnames in os.walk(wpt_root):
+ # Walk top_level_subdir looking for test files containing either the
+ # relative filepath or absolute filepath to the changed files.
+ if root == wpt_root:
+ for dir_name in skip_tests:
+ dirs.remove(dir_name)
+ for fname in fnames:
+ test_full_path = os.path.join(root, fname)
+ # Skip any file that's not a test file.
+ if test_full_path not in test_files:
+ continue
+ if affected_by_wdspec(test_full_path):
+ affected_testfiles.add(test_full_path)
+ continue
+
+ with open(test_full_path, "rb") as fh:
+ file_contents = fh.read()
+ if file_contents.startswith("\xfe\xff"):
+ file_contents = file_contents.decode("utf-16be", "replace")
+ elif file_contents.startswith("\xff\xfe"):
+ file_contents = file_contents.decode("utf-16le", "replace")
+ else:
+ file_contents = file_contents.decode("utf8", "replace")
+ for full_path, repo_path in nontest_changed_paths:
+ rel_path = os.path.relpath(full_path, root).replace(os.path.sep, "/")
+ if rel_path in file_contents or repo_path in file_contents:
+ affected_testfiles.add(test_full_path)
+ continue
+
+ return tests_changed, affected_testfiles
+
+
+def get_parser():
+ parser = argparse.ArgumentParser()
+ parser.add_argument("revish", default=None, help="Commits to consider. Defaults to the commits on the current branch", nargs="?")
+ parser.add_argument("--ignore-dirs", nargs="*", type=set, default=set(["resources"]),
+ help="Directories to exclude from the list of changes")
+ parser.add_argument("--modified", action="store_true",
+ help="Include files under version control that have been modified or staged")
+ parser.add_argument("--new", action="store_true",
+ help="Include files in the worktree that are not in version control")
+ parser.add_argument("--show-type", action="store_true",
+ help="Print the test type along with each affected test")
+ return parser
+
+
+def get_parser_affected():
+ parser = get_parser()
+ parser.add_argument("--metadata",
+ dest="metadata_root",
+ action="store",
+ default=wpt_root,
+ help="Directory that will contain MANIFEST.json")
+ return parser
+
+def get_revish(**kwargs):
+ revish = kwargs["revish"]
+ if kwargs["revish"] is None:
+ revish = "%s..HEAD" % branch_point()
+ return revish
+
+
+def run_changed_files(**kwargs):
+ revish = get_revish(**kwargs)
+ changed, _ = files_changed(revish, kwargs["ignore_dirs"],
+ include_uncommitted=kwargs["modified"],
+ include_new=kwargs["new"])
+ for item in sorted(changed):
+ print(os.path.relpath(item, wpt_root))
+
+
+def run_tests_affected(**kwargs):
+ revish = get_revish(**kwargs)
+ changed, _ = files_changed(revish, kwargs["ignore_dirs"],
+ include_uncommitted=kwargs["modified"],
+ include_new=kwargs["new"])
+ manifest_path = os.path.join(kwargs["metadata_root"], "MANIFEST.json")
+ tests_changed, dependents = affected_testfiles(
+ changed,
+ set(["conformance-checkers", "docs", "tools"]),
+ manifest_path=manifest_path
+ )
+
+ message = "{path}"
+ if kwargs["show_type"]:
+ wpt_manifest = load_manifest(manifest_path)
+ message = "{path}\t{item_type}"
+ for item in sorted(tests_changed | dependents):
+ results = {
+ "path": os.path.relpath(item, wpt_root)
+ }
+ if kwargs["show_type"]:
+ item_types = {i.item_type for i in wpt_manifest.iterpath(results["path"])}
+ if len(item_types) != 1:
+ item_types = [" ".join(item_types)]
+ results["item_type"] = item_types.pop()
+ print(message.format(**results))
diff --git a/src/third_party/web_platform_tests/tools/wpt/tests/test_wpt.py b/src/third_party/web_platform_tests/tools/wpt/tests/test_wpt.py
new file mode 100644
index 0000000..e3b8d1f
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/tests/test_wpt.py
@@ -0,0 +1,138 @@
+import os
+import shutil
+import socket
+import subprocess
+import time
+import urllib2
+
+import pytest
+
+from tools.wpt import wpt
+
+
+# Tests currently don't work on Windows for path reasons
+
+def test_missing():
+ with pytest.raises(SystemExit):
+ wpt.main(argv=["#missing-command"])
+
+
+def test_help():
+ # TODO: It seems like there's a bug in argparse that makes this argument order required
+ # should try to work around that
+ with pytest.raises(SystemExit) as excinfo:
+ wpt.main(argv=["--help"])
+ assert excinfo.value.code == 0
+
+
+def test_run_firefox():
+ # TODO: It seems like there's a bug in argparse that makes this argument order required
+ # should try to work around that
+ os.environ["MOZ_HEADLESS"] = "1"
+ try:
+ fx_path = os.path.join(wpt.localpaths.repo_root, "_venv", "firefox")
+ if os.path.exists(fx_path):
+ shutil.rmtree(fx_path)
+ with pytest.raises(SystemExit) as excinfo:
+ wpt.main(argv=["run", "--no-pause", "--install-browser", "--yes",
+ "--metadata", "~/meta/",
+ "firefox", "/dom/nodes/Element-tagName.html"])
+ assert os.path.exists(fx_path)
+ shutil.rmtree(fx_path)
+ assert excinfo.value.code == 0
+ finally:
+ del os.environ["MOZ_HEADLESS"]
+
+
+def test_run_chrome():
+ with pytest.raises(SystemExit) as excinfo:
+ wpt.main(argv=["run", "--yes", "--no-pause", "--binary-arg", "headless",
+ "--metadata", "~/meta/",
+ "chrome", "/dom/nodes/Element-tagName.html"])
+ assert excinfo.value.code == 0
+
+
+def test_install_chromedriver():
+ chromedriver_path = os.path.join(wpt.localpaths.repo_root, "_venv", "bin", "chromedriver")
+ if os.path.exists(chromedriver_path):
+ os.unlink(chromedriver_path)
+ with pytest.raises(SystemExit) as excinfo:
+ wpt.main(argv=["install", "chrome", "webdriver"])
+ assert excinfo.value.code == 0
+ assert os.path.exists(chromedriver_path)
+ os.unlink(chromedriver_path)
+
+
+def test_install_firefox():
+ fx_path = os.path.join(wpt.localpaths.repo_root, "_venv", "firefox")
+ if os.path.exists(fx_path):
+ shutil.rmtree(fx_path)
+ with pytest.raises(SystemExit) as excinfo:
+ wpt.main(argv=["install", "firefox", "browser"])
+ assert excinfo.value.code == 0
+ assert os.path.exists(fx_path)
+ shutil.rmtree(fx_path)
+
+
+def test_files_changed(capsys):
+ commit = "9047ac1d9f51b1e9faa4f9fad9c47d109609ab09"
+ with pytest.raises(SystemExit) as excinfo:
+ wpt.main(argv=["files-changed", "%s~..%s" % (commit, commit)])
+ assert excinfo.value.code == 0
+ out, err = capsys.readouterr()
+ assert out == """html/browsers/offline/appcache/workers/appcache-worker.html
+html/browsers/offline/appcache/workers/resources/appcache-dedicated-worker-not-in-cache.js
+html/browsers/offline/appcache/workers/resources/appcache-shared-worker-not-in-cache.js
+html/browsers/offline/appcache/workers/resources/appcache-worker-data.py
+html/browsers/offline/appcache/workers/resources/appcache-worker-import.py
+html/browsers/offline/appcache/workers/resources/appcache-worker.manifest
+html/browsers/offline/appcache/workers/resources/appcache-worker.py
+"""
+ assert err == ""
+
+
+def test_tests_affected(capsys):
+ # This doesn't really work properly for random commits because we test the files in
+ # the current working directory for references to the changed files, not the ones at
+ # that specific commit. But we can at least test it returns something sensible
+ commit = "9047ac1d9f51b1e9faa4f9fad9c47d109609ab09"
+ with pytest.raises(SystemExit) as excinfo:
+ wpt.main(argv=["tests-affected", "--metadata", "~/meta/", "%s~..%s" % (commit, commit)])
+ assert excinfo.value.code == 0
+ out, err = capsys.readouterr()
+ assert "html/browsers/offline/appcache/workers/appcache-worker.html" in out
+ assert err == ""
+
+
+def test_serve():
+ def test():
+ s = socket.socket()
+ s.connect(("127.0.0.1", 8000))
+ with pytest.raises(socket.error):
+ test()
+
+ p = subprocess.Popen([os.path.join(wpt.localpaths.repo_root, "wpt"), "serve"],
+ preexec_fn=os.setsid)
+
+ start = time.time()
+ try:
+ while True:
+ if time.time() - start > 60:
+ assert False
+ try:
+ resp = urllib2.urlopen("http://web-platform.test:8000")
+ print resp
+ except urllib2.URLError:
+ print "URLError"
+ time.sleep(1)
+ else:
+ assert resp.code == 200
+ break
+ finally:
+ os.killpg(p.pid, 15)
+
+# The following commands are slow running and used implicitly in other CI
+# jobs, so we skip them here:
+# wpt check-stability
+# wpt manifest
+# wpt lint
diff --git a/src/third_party/web_platform_tests/tools/wpt/tox.ini b/src/third_party/web_platform_tests/tools/wpt/tox.ini
new file mode 100644
index 0000000..5836a52
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/tox.ini
@@ -0,0 +1,21 @@
+[tox]
+envlist = py27
+skipsdist=True
+
+[testenv]
+deps =
+ flake8
+ pytest
+ pytest-cov
+ hypothesis
+ -r{toxinidir}/../wptrunner/requirements.txt
+ -r{toxinidir}/../wptrunner/requirements_chrome.txt
+ -r{toxinidir}/../wptrunner/requirements_firefox.txt
+
+commands =
+ pytest --cov
+ flake8
+
+[flake8]
+ignore = E128,E129,E221,E226,E231,E251,E265,E302,E303,E305,E402,E901,F401,F821,F841
+max-line-length = 141
diff --git a/src/third_party/web_platform_tests/tools/wpt/utils.py b/src/third_party/web_platform_tests/tools/wpt/utils.py
new file mode 100644
index 0000000..32e780f
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/utils.py
@@ -0,0 +1,113 @@
+import logging
+import os
+import subprocess
+import sys
+import tarfile
+import zipfile
+from io import BytesIO
+
+logger = logging.getLogger(__name__)
+
+
+class Kwargs(dict):
+ def set_if_none(self, name, value, err_fn=None, desc=None, extra_cond=None):
+ if desc is None:
+ desc = name
+
+ if self[name] is None:
+ if extra_cond is not None and not extra_cond(self):
+ return
+ if callable(value):
+ value = value()
+ if not value:
+ if err_fn is not None:
+ return err_fn(kwargs, "Failed to find %s" % desc)
+ else:
+ return
+ self[name] = value
+ logger.info("Set %s to %s" % (desc, value))
+
+
+def call(*args):
+ """Log terminal command, invoke it as a subprocess.
+
+ Returns a bytestring of the subprocess output if no error.
+ """
+ logger.debug("%s" % " ".join(args))
+ try:
+ return subprocess.check_output(args)
+ except subprocess.CalledProcessError as e:
+ logger.critical("%s exited with return code %i" %
+ (e.cmd, e.returncode))
+ logger.critical(e.output)
+ raise
+
+
+def get_git_cmd(repo_path):
+ """Create a function for invoking git commands as a subprocess."""
+ def git(cmd, *args):
+ full_cmd = ["git", cmd] + list(args)
+ try:
+ logger.debug(" ".join(full_cmd))
+ return subprocess.check_output(full_cmd, cwd=repo_path, stderr=subprocess.STDOUT).strip()
+ except subprocess.CalledProcessError as e:
+ logger.error("Git command exited with status %i" % e.returncode)
+ logger.error(e.output)
+ sys.exit(1)
+ return git
+
+
+def seekable(fileobj):
+ """Attempt to use file.seek on given file, with fallbacks."""
+ try:
+ fileobj.seek(fileobj.tell())
+ except Exception:
+ return BytesIO(fileobj.read())
+ else:
+ return fileobj
+
+
+def untar(fileobj, dest="."):
+ """Extract tar archive."""
+ logger.debug("untar")
+ fileobj = seekable(fileobj)
+ with tarfile.open(fileobj=fileobj) as tar_data:
+ tar_data.extractall(path=dest)
+
+
+def unzip(fileobj, dest=None, limit=None):
+ """Extract zip archive."""
+ logger.debug("unzip")
+ fileobj = seekable(fileobj)
+ with zipfile.ZipFile(fileobj) as zip_data:
+ for info in zip_data.infolist():
+ if limit is not None and info.filename not in limit:
+ continue
+ zip_data.extract(info, path=dest)
+ perm = info.external_attr >> 16 & 0x1FF
+ os.chmod(os.path.join(dest, info.filename), perm)
+
+
+class pwd(object):
+ """Create context for temporarily changing present working directory."""
+ def __init__(self, dir):
+ self.dir = dir
+ self.old_dir = None
+
+ def __enter__(self):
+ self.old_dir = os.path.abspath(os.curdir)
+ os.chdir(self.dir)
+
+ def __exit__(self, *args, **kwargs):
+ os.chdir(self.old_dir)
+ self.old_dir = None
+
+
+def get(url):
+ """Issue GET request to a given URL and return the response."""
+ import requests
+
+ logger.debug("GET %s" % url)
+ resp = requests.get(url, stream=True)
+ resp.raise_for_status()
+ return resp
diff --git a/src/third_party/web_platform_tests/tools/wpt/virtualenv.py b/src/third_party/web_platform_tests/tools/wpt/virtualenv.py
new file mode 100644
index 0000000..8f36aa9
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/virtualenv.py
@@ -0,0 +1,52 @@
+import os
+import sys
+import logging
+from distutils.spawn import find_executable
+
+from tools.wpt.utils import call
+
+logger = logging.getLogger(__name__)
+
+class Virtualenv(object):
+ def __init__(self, path):
+ self.path = path
+ self.virtualenv = find_executable("virtualenv")
+ if not self.virtualenv:
+ raise ValueError("virtualenv must be installed and on the PATH")
+
+ @property
+ def exists(self):
+ return os.path.isdir(self.path)
+
+ def create(self):
+ if os.path.exists(self.path):
+ shutil.rmtree(self.path)
+ call(self.virtualenv, self.path)
+
+ @property
+ def bin_path(self):
+ if sys.platform in ("win32", "cygwin"):
+ return os.path.join(self.path, "Scripts")
+ return os.path.join(self.path, "bin")
+
+ @property
+ def pip_path(self):
+ path = find_executable("pip", self.bin_path)
+ if path is None:
+ raise ValueError("pip not found")
+ return path
+
+ def activate(self):
+ path = os.path.join(self.bin_path, "activate_this.py")
+ execfile(path, {"__file__": path})
+
+ def start(self):
+ if not self.exists:
+ self.create()
+ self.activate()
+
+ def install(self, *requirements):
+ call(self.pip_path, "install", *requirements)
+
+ def install_requirements(self, requirements_path):
+ call(self.pip_path, "install", "-r", requirements_path)
diff --git a/src/third_party/web_platform_tests/tools/wpt/wpt.py b/src/third_party/web_platform_tests/tools/wpt/wpt.py
new file mode 100644
index 0000000..cf94ce0
--- /dev/null
+++ b/src/third_party/web_platform_tests/tools/wpt/wpt.py
@@ -0,0 +1,142 @@
+import argparse
+import os
+import json
+import sys
+
+from tools import localpaths
+
+from six import iteritems
+from . import virtualenv
+
+
+here = os.path.dirname(__file__)
+wpt_root = os.path.abspath(os.path.join(here, os.pardir, os.pardir))
+
+
+def load_commands():
+ rv = {}
+ with open(os.path.join(here, "paths"), "r") as f:
+ paths = [item.strip().replace("/", os.path.sep) for item in f if item.strip()]
+ for path in paths:
+ abs_path = os.path.join(wpt_root, path, "commands.json")
+ base_dir = os.path.dirname(abs_path)
+ with open(abs_path, "r") as f:
+ data = json.load(f)
+ for command, props in iteritems(data):
+ assert "path" in props
+ assert "script" in props
+ rv[command] = {
+ "path": os.path.join(base_dir, props["path"]),
+ "script": props["script"],
+ "parser": props.get("parser"),
+ "parse_known": props.get("parse_known", False),
+ "help": props.get("help"),
+ "virtualenv": props.get("virtualenv", True),
+ "install": props.get("install", []),
+ "requirements": [os.path.join(base_dir, item)
+ for item in props.get("requirements", [])]
+ }
+ return rv
+
+
+def parse_args(argv, commands):
+ parser = argparse.ArgumentParser()
+ parser.add_argument("--venv", action="store", help="Path to an existing virtualenv to use")
+ parser.add_argument("--debug", action="store_true", help="Run the debugger in case of an exception")
+ subparsers = parser.add_subparsers(dest="command")
+ for command, props in iteritems(commands):
+ sub_parser = subparsers.add_parser(command, help=props["help"], add_help=False)
+
+ args, extra = parser.parse_known_args(argv)
+
+ return args, extra
+
+
+def import_command(prog, command, props):
+ # This currently requires the path to be a module,
+ # which probably isn't ideal but it means that relative
+ # imports inside the script work
+ rel_path = os.path.relpath(props["path"], wpt_root)
+
+ parts = os.path.splitext(rel_path)[0].split(os.path.sep)
+
+ mod_name = ".".join(parts)
+
+ mod = __import__(mod_name)
+ for part in parts[1:]:
+ mod = getattr(mod, part)
+
+ script = getattr(mod, props["script"])
+ if props["parser"] is not None:
+ parser = getattr(mod, props["parser"])()
+ parser.prog = "%s %s" % (os.path.basename(prog), command)
+ else:
+ parser = None
+
+ return script, parser
+
+
+def setup_virtualenv(path, props):
+ if path is None:
+ path = os.path.join(wpt_root, "_venv")
+ venv = virtualenv.Virtualenv(path)
+ venv.start()
+ for name in props["install"]:
+ venv.install(name)
+ for path in props["requirements"]:
+ venv.install_requirements(path)
+ return venv
+
+
+def main(prog=None, argv=None):
+ if prog is None:
+ prog = sys.argv[0]
+ if argv is None:
+ argv = sys.argv[1:]
+
+ commands = load_commands()
+
+ main_args, command_args = parse_args(argv, commands)
+
+ if not(len(argv) and argv[0] in commands):
+ sys.exit(1)
+
+ command = main_args.command
+ props = commands[command]
+ venv = None
+ if props["virtualenv"]:
+ venv = setup_virtualenv(main_args.venv, props)
+ script, parser = import_command(prog, command, props)
+ if parser:
+ if props["parse_known"]:
+ kwargs, extras = parser.parse_known_args(command_args)
+ extras = (extras,)
+ kwargs = vars(kwargs)
+ else:
+ extras = ()
+ kwargs = vars(parser.parse_args(command_args))
+ else:
+ extras = ()
+ kwargs = {}
+
+ if venv is not None:
+ args = (venv,) + extras
+ else:
+ args = extras
+
+ if script:
+ try:
+ rv = script(*args, **kwargs)
+ if rv is not None:
+ sys.exit(int(rv))
+ except Exception:
+ if main_args.debug:
+ import pdb
+ pdb.post_mortem()
+ else:
+ raise
+ sys.exit(0)
+
+
+if __name__ == "__main__":
+ main()
