summaryrefslogtreecommitdiffstats
path: root/testing/web-platform/tests/tools/manifest/item.py
diff options
context:
space:
mode:
Diffstat (limited to 'testing/web-platform/tests/tools/manifest/item.py')
-rw-r--r--testing/web-platform/tests/tools/manifest/item.py342
1 files changed, 342 insertions, 0 deletions
diff --git a/testing/web-platform/tests/tools/manifest/item.py b/testing/web-platform/tests/tools/manifest/item.py
new file mode 100644
index 0000000000..500ca109a7
--- /dev/null
+++ b/testing/web-platform/tests/tools/manifest/item.py
@@ -0,0 +1,342 @@
+import os.path
+from abc import ABCMeta, abstractproperty
+from inspect import isabstract
+from typing import (Any, Dict, Hashable, List, Optional, Sequence, Text, Tuple, Type,
+ TYPE_CHECKING, Union, cast)
+from urllib.parse import urljoin, urlparse, parse_qs
+
+from .utils import to_os_path
+
+if TYPE_CHECKING:
+ from .manifest import Manifest
+
+Fuzzy = Dict[Optional[Tuple[str, str, str]], List[int]]
+PageRanges = Dict[str, List[int]]
+item_types: Dict[str, Type["ManifestItem"]] = {}
+
+
+class ManifestItemMeta(ABCMeta):
+ """Custom metaclass that registers all the subclasses in the
+ item_types dictionary according to the value of their item_type
+ attribute, and otherwise behaves like an ABCMeta."""
+
+ def __new__(cls: Type["ManifestItemMeta"], name: str, bases: Tuple[type], attrs: Dict[str, Any]) -> "ManifestItemMeta":
+ inst = super().__new__(cls, name, bases, attrs)
+ if isabstract(inst):
+ return inst
+
+ assert issubclass(inst, ManifestItem)
+ item_type = cast(str, inst.item_type)
+
+ item_types[item_type] = inst
+
+ return inst
+
+
+class ManifestItem(metaclass=ManifestItemMeta):
+ __slots__ = ("_tests_root", "path")
+
+ def __init__(self, tests_root: Text, path: Text) -> None:
+ self._tests_root = tests_root
+ self.path = path
+
+ @abstractproperty
+ def id(self) -> Text:
+ """The test's id (usually its url)"""
+ pass
+
+ @abstractproperty
+ def item_type(self) -> str:
+ """The item's type"""
+ pass
+
+ @property
+ def path_parts(self) -> Tuple[Text, ...]:
+ return tuple(self.path.split(os.path.sep))
+
+ def key(self) -> Hashable:
+ """A unique identifier for the test"""
+ return (self.item_type, self.id)
+
+ def __eq__(self, other: Any) -> bool:
+ if not hasattr(other, "key"):
+ return False
+ return bool(self.key() == other.key())
+
+ def __hash__(self) -> int:
+ return hash(self.key())
+
+ def __repr__(self) -> str:
+ return f"<{self.__module__}.{self.__class__.__name__} id={self.id!r}, path={self.path!r}>"
+
+ def to_json(self) -> Tuple[Any, ...]:
+ return ()
+
+ @classmethod
+ def from_json(cls,
+ manifest: "Manifest",
+ path: Text,
+ obj: Any
+ ) -> "ManifestItem":
+ path = to_os_path(path)
+ tests_root = manifest.tests_root
+ assert tests_root is not None
+ return cls(tests_root, path)
+
+
+class URLManifestItem(ManifestItem):
+ __slots__ = ("url_base", "_url", "_extras", "_flags")
+
+ def __init__(self,
+ tests_root: Text,
+ path: Text,
+ url_base: Text,
+ url: Optional[Text],
+ **extras: Any
+ ) -> None:
+ super().__init__(tests_root, path)
+ assert url_base[0] == "/"
+ self.url_base = url_base
+ assert url is None or url[0] != "/"
+ self._url = url
+ self._extras = extras
+ parsed_url = urlparse(self.url)
+ self._flags = (set(parsed_url.path.rsplit("/", 1)[1].split(".")[1:-1]) |
+ set(parse_qs(parsed_url.query).get("wpt_flags", [])))
+
+ @property
+ def id(self) -> Text:
+ return self.url
+
+ @property
+ def url(self) -> Text:
+ rel_url = self._url or self.path.replace(os.path.sep, "/")
+ # we can outperform urljoin, because we know we just have path relative URLs
+ if self.url_base == "/":
+ return "/" + rel_url
+ return urljoin(self.url_base, rel_url)
+
+ @property
+ def https(self) -> bool:
+ return "https" in self._flags or "serviceworker" in self._flags or "serviceworker-module" in self._flags
+
+ @property
+ def h2(self) -> bool:
+ return "h2" in self._flags
+
+ @property
+ def subdomain(self) -> bool:
+ # Note: this is currently hard-coded to check for `www`, rather than
+ # all possible valid subdomains. It can be extended if needed.
+ return "www" in self._flags
+
+ def to_json(self) -> Tuple[Optional[Text], Dict[Any, Any]]:
+ rel_url = None if self._url == self.path.replace(os.path.sep, "/") else self._url
+ rv: Tuple[Optional[Text], Dict[Any, Any]] = (rel_url, {})
+ return rv
+
+ @classmethod
+ def from_json(cls,
+ manifest: "Manifest",
+ path: Text,
+ obj: Tuple[Text, Dict[Any, Any]]
+ ) -> "URLManifestItem":
+ path = to_os_path(path)
+ url, extras = obj
+ tests_root = manifest.tests_root
+ assert tests_root is not None
+ return cls(tests_root,
+ path,
+ manifest.url_base,
+ url,
+ **extras)
+
+
+class TestharnessTest(URLManifestItem):
+ __slots__ = ()
+
+ item_type = "testharness"
+
+ @property
+ def timeout(self) -> Optional[Text]:
+ return self._extras.get("timeout")
+
+ @property
+ def pac(self) -> Optional[Text]:
+ return self._extras.get("pac")
+
+ @property
+ def testdriver(self) -> Optional[Text]:
+ return self._extras.get("testdriver")
+
+ @property
+ def jsshell(self) -> Optional[Text]:
+ return self._extras.get("jsshell")
+
+ @property
+ def script_metadata(self) -> Optional[List[Tuple[Text, Text]]]:
+ return self._extras.get("script_metadata")
+
+ def to_json(self) -> Tuple[Optional[Text], Dict[Text, Any]]:
+ rv = super().to_json()
+ if self.timeout is not None:
+ rv[-1]["timeout"] = self.timeout
+ if self.pac is not None:
+ rv[-1]["pac"] = self.pac
+ if self.testdriver:
+ rv[-1]["testdriver"] = self.testdriver
+ if self.jsshell:
+ rv[-1]["jsshell"] = True
+ if self.script_metadata:
+ rv[-1]["script_metadata"] = [(k, v) for (k,v) in self.script_metadata]
+ return rv
+
+
+class RefTest(URLManifestItem):
+ __slots__ = ("references",)
+
+ item_type = "reftest"
+
+ def __init__(self,
+ tests_root: Text,
+ path: Text,
+ url_base: Text,
+ url: Optional[Text],
+ references: Optional[List[Tuple[Text, Text]]] = None,
+ **extras: Any
+ ):
+ super().__init__(tests_root, path, url_base, url, **extras)
+ if references is None:
+ self.references: List[Tuple[Text, Text]] = []
+ else:
+ self.references = references
+
+ @property
+ def timeout(self) -> Optional[Text]:
+ return self._extras.get("timeout")
+
+ @property
+ def viewport_size(self) -> Optional[Text]:
+ return self._extras.get("viewport_size")
+
+ @property
+ def dpi(self) -> Optional[Text]:
+ return self._extras.get("dpi")
+
+ @property
+ def fuzzy(self) -> Fuzzy:
+ fuzzy: Union[Fuzzy, List[Tuple[Optional[Sequence[Text]], List[int]]]] = self._extras.get("fuzzy", {})
+ if not isinstance(fuzzy, list):
+ return fuzzy
+
+ rv: Fuzzy = {}
+ for k, v in fuzzy: # type: Tuple[Optional[Sequence[Text]], List[int]]
+ if k is None:
+ key: Optional[Tuple[Text, Text, Text]] = None
+ else:
+ # mypy types this as Tuple[Text, ...]
+ assert len(k) == 3
+ key = tuple(k) # type: ignore
+ rv[key] = v
+ return rv
+
+ def to_json(self) -> Tuple[Optional[Text], List[Tuple[Text, Text]], Dict[Text, Any]]: # type: ignore
+ rel_url = None if self._url == self.path else self._url
+ rv: Tuple[Optional[Text], List[Tuple[Text, Text]], Dict[Text, Any]] = (rel_url, self.references, {})
+ extras = rv[-1]
+ if self.timeout is not None:
+ extras["timeout"] = self.timeout
+ if self.viewport_size is not None:
+ extras["viewport_size"] = self.viewport_size
+ if self.dpi is not None:
+ extras["dpi"] = self.dpi
+ if self.fuzzy:
+ extras["fuzzy"] = list(self.fuzzy.items())
+ return rv
+
+ @classmethod
+ def from_json(cls, # type: ignore
+ manifest: "Manifest",
+ path: Text,
+ obj: Tuple[Text, List[Tuple[Text, Text]], Dict[Any, Any]]
+ ) -> "RefTest":
+ tests_root = manifest.tests_root
+ assert tests_root is not None
+ path = to_os_path(path)
+ url, references, extras = obj
+ return cls(tests_root,
+ path,
+ manifest.url_base,
+ url,
+ references,
+ **extras)
+
+
+class PrintRefTest(RefTest):
+ __slots__ = ("references",)
+
+ item_type = "print-reftest"
+
+ @property
+ def page_ranges(self) -> PageRanges:
+ return self._extras.get("page_ranges", {})
+
+ def to_json(self): # type: ignore
+ rv = super().to_json()
+ if self.page_ranges:
+ rv[-1]["page_ranges"] = self.page_ranges
+ return rv
+
+
+class ManualTest(URLManifestItem):
+ __slots__ = ()
+
+ item_type = "manual"
+
+
+class ConformanceCheckerTest(URLManifestItem):
+ __slots__ = ()
+
+ item_type = "conformancechecker"
+
+
+class VisualTest(URLManifestItem):
+ __slots__ = ()
+
+ item_type = "visual"
+
+
+class CrashTest(URLManifestItem):
+ __slots__ = ()
+
+ item_type = "crashtest"
+
+ @property
+ def timeout(self) -> Optional[Text]:
+ return None
+
+
+class WebDriverSpecTest(URLManifestItem):
+ __slots__ = ()
+
+ item_type = "wdspec"
+
+ @property
+ def timeout(self) -> Optional[Text]:
+ return self._extras.get("timeout")
+
+ def to_json(self) -> Tuple[Optional[Text], Dict[Text, Any]]:
+ rv = super().to_json()
+ if self.timeout is not None:
+ rv[-1]["timeout"] = self.timeout
+ return rv
+
+
+class SupportFile(ManifestItem):
+ __slots__ = ()
+
+ item_type = "support"
+
+ @property
+ def id(self) -> Text:
+ return self.path
generated by cgit v1.2.3 (git 2.39.1) at 2024-12-24 01:34:54 +0000