| # Copyright 2017 The Chromium Authors. All rights reserved. |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| |
| """WPTManifest is responsible for handling MANIFEST.json. |
| |
| The MANIFEST.json file contains metadata about files in web-platform-tests, |
| such as what tests exist, and extra information about each test, including |
| test type, options, URLs to use, and reference file paths if applicable. |
| """ |
| |
| import json |
| import logging |
| |
| from webkitpy.common.webkit_finder import WebKitFinder |
| |
| _log = logging.getLogger(__file__) |
| |
| |
| class WPTManifest(object): |
| |
| def __init__(self, json_content): |
| # TODO(tkent): Create a Manifest object by Manifest.from_json(). |
| # See ../thirdparty/wpt/wpt/tools/manifest/manifest.py. |
| self.raw_dict = json.loads(json_content) |
| |
| def _items_for_path(self, path_in_wpt): |
| """Returns manifest items for the given WPT path, or None if not found. |
| |
| The format of a manifest item depends on |
| https://github.com/w3c/wpt-tools/blob/master/manifest/item.py |
| and is assumed to be a list of the format [url, extras], |
| or [url, references, extras] for reftests, or None if not found. |
| |
| For most testharness tests, the returned items is expected |
| to look like this:: [["/some/test/path.html", {}]] |
| """ |
| items = self.raw_dict['items'] |
| if path_in_wpt in items['manual']: |
| return items['manual'][path_in_wpt] |
| elif path_in_wpt in items['reftest']: |
| return items['reftest'][path_in_wpt] |
| elif path_in_wpt in items['testharness']: |
| return items['testharness'][path_in_wpt] |
| return None |
| |
| def is_test_file(self, path_in_wpt): |
| return self._items_for_path(path_in_wpt) is not None |
| |
| def file_path_to_url_paths(self, path_in_wpt): |
| manifest_items = self._items_for_path(path_in_wpt) |
| assert manifest_items is not None |
| if len(manifest_items) != 1: |
| return [] |
| url = manifest_items[0][0] |
| if url[1:] != path_in_wpt: |
| # TODO(tkent): foo.any.js and bar.worker.js should be accessed |
| # as foo.any.html, foo.any.worker, and bar.worker with WPTServe. |
| return [] |
| return [path_in_wpt] |
| |
| @staticmethod |
| def _get_extras_from_item(item): |
| return item[-1] |
| |
| def is_slow_test(self, test_name): |
| items = self._items_for_path(test_name) |
| if not items: |
| return False |
| extras = WPTManifest._get_extras_from_item(items[0]) |
| return 'timeout' in extras and extras['timeout'] == 'long' |
| |
| def extract_reference_list(self, path_in_wpt): |
| """Extracts reference information of the specified reference test. |
| |
| The return value is a list of (match/not-match, reference path in wpt) |
| like: |
| [("==", "foo/bar/baz-match.html"), |
| ("!=", "foo/bar/baz-mismatch.html")] |
| """ |
| all_items = self.raw_dict['items'] |
| if path_in_wpt not in all_items['reftest']: |
| return [] |
| reftest_list = [] |
| for item in all_items['reftest'][path_in_wpt]: |
| for ref_path_in_wpt, expectation in item[1]: |
| reftest_list.append((expectation, ref_path_in_wpt)) |
| return reftest_list |
| |
| @staticmethod |
| def ensure_manifest(host): |
| """Checks whether the manifest exists, and then generates it if necessary.""" |
| finder = WebKitFinder(host.filesystem) |
| manifest_path = finder.path_from_webkit_base('LayoutTests', 'external', 'wpt', 'MANIFEST.json') |
| base_manifest_path = finder.path_from_webkit_base('LayoutTests', 'external', 'WPT_BASE_MANIFEST.json') |
| |
| if not host.filesystem.exists(base_manifest_path): |
| _log.error('Manifest base not found at "%s".', base_manifest_path) |
| host.filesystem.write_text_file(base_manifest_path, '{}') |
| |
| if not host.filesystem.exists(manifest_path): |
| _log.debug('Manifest not found, copying from base "%s".', base_manifest_path) |
| host.filesystem.copyfile(base_manifest_path, manifest_path) |
| |
| wpt_path = manifest_path = finder.path_from_webkit_base('LayoutTests', 'external', 'wpt') |
| WPTManifest.generate_manifest(host, wpt_path) |
| |
| @staticmethod |
| def generate_manifest(host, dest_path): |
| """Generates MANIFEST.json on the specified directory.""" |
| executive = host.executive |
| finder = WebKitFinder(host.filesystem) |
| manifest_exec_path = finder.path_from_webkit_base('Tools', 'Scripts', 'webkitpy', 'thirdparty', 'wpt', 'wpt', 'manifest') |
| |
| cmd = ['python', manifest_exec_path, '--work', '--tests-root', dest_path] |
| _log.debug('Running command: %s', ' '.join(cmd)) |
| proc = executive.popen(cmd, stdout=executive.PIPE, stderr=executive.PIPE, stdin=executive.PIPE, cwd=finder.webkit_base()) |
| out, err = proc.communicate('') |
| if proc.returncode: |
| _log.info('# ret> %d', proc.returncode) |
| if out: |
| _log.info(out) |
| if err: |
| _log.info(err) |
| host.exit(proc.returncode) |
| return proc.returncode, out |
