Skipped tests don't need to record their argv

Removes some duplication and complexity.  Also, tighten up validation to
ensure we use streams (readable or writable pipes, sockets) in an
appropriate way.

Author: wingo

test-runner/wasi_test_runner/test_case.py

@@ -1,7 +1,7 @@
 import logging
 import json
 from pathlib import Path
-from enum import StrEnum
+from enum import Enum, StrEnum, auto
 from typing import List, NamedTuple, TypeVar, Type, Dict, Any, Set, Tuple
 
 # Top level configuration keys
@@ -237,13 +237,6 @@ def from_file(cls: Type[T], config_file: str) -> T:
             proposals=[],
         )
 
-    def args_env_dirs(self) -> Tuple[List[str], Dict[str, str], List[Tuple[Path, str]]]:
-        for op in self.operations:
-            match op:
-                case Run(args, env, dirs):
-                    return (args, env, dirs)
-        return ([], {}, [])
-
     def proposals_as_str(self) -> List[str]:
         return [p.value for p in self.proposals]
 
@@ -381,45 +374,57 @@ def run(self) -> Result:
         return self.as_result()
 
 
+class StreamType(Enum):
+    READABLE_PIPE = auto()
+    WRITABLE_PIPE = auto()
+    SOCKET = auto()
+
+
 class TestCaseValidator(TestCaseRunnerBase):
     _config_path: str
     _has_proc: bool
-    _streams: Set[str]
+    _streams: Dict[str, StreamType]
 
     def __init__(self, config: Config, config_path: str) -> None:
         TestCaseRunnerBase.__init__(self, config)
         self._config_path = config_path
         self._has_proc = False
-        self._streams = set()
+        self._streams = {}
 
     def assert_proc(self, op: Any) -> None:
-        assert self._has_proc, f"{op}: no process running"
+        assert self._has_proc, \
+            f"{self._config_path}: {op}: no process running"
 
     def assert_no_proc(self, op: Any) -> None:
-        assert not self._has_proc, f"{op}: process still running"
+        assert not self._has_proc, \
+            f"{self._config_path}: {op}: process still running"
 
-    def assert_stream(self, op: Any, name: str) -> None:
-        assert name in self._streams, f"{op}: no such stream: {name}"
+    def assert_stream(self, op: Any, name: str, typ: StreamType) -> None:
+        assert name in self._streams, \
+            f"{self._config_path}: {op}: no such stream: {name}"
+        t = self._streams[name]
+        assert t == typ, \
+            f"{self._config_path}: {op}: expected {typ}, but got {t}: {name}"
 
-    def assert_no_stream(self, op: Any, name: str) -> None:
-        assert name not in self._streams, f"{op}: stream exists: {name}"
+    def add_stream(self, op: Any, name: str, typ: StreamType) -> None:
+        assert name not in self._streams, \
+            f"{self._config_path}: {op}: stream exists: {name}"
+        self._streams[name] = typ
 
     def do_run(self, run: Run) -> None:
         self.assert_no_proc(run)
+        self.add_stream(run, "stdin", StreamType.WRITABLE_PIPE)
+        self.add_stream(run, "stdout", StreamType.READABLE_PIPE)
+        self.add_stream(run, "stderr", StreamType.READABLE_PIPE)
         self._has_proc = True
 
     def do_write(self, write: Write) -> None:
         self.assert_proc(write)
-        match write.id:
-            case "stdin": pass
-            case name: self.assert_stream(write, name)
+        self.assert_stream(write, write.id, StreamType.WRITABLE_PIPE)
 
     def do_read(self, read: Read) -> None:
         self.assert_proc(read)
-        match read.id:
-            case "stdout": pass
-            case "stderr": pass
-            case name: self.assert_stream(read, name)
+        self.assert_stream(read, read.id, StreamType.READABLE_PIPE)
 
     def do_wait(self, wait: Wait) -> None:
         self.assert_proc(wait)
@@ -428,18 +433,17 @@ def do_wait(self, wait: Wait) -> None:
 
     def do_connect(self, conn: Connect) -> None:
         self.assert_proc(conn)
-        self.assert_no_stream(conn, conn.id)
         assert conn.protocol_type == ProtocolType.TCP, \
-            f"{conn}: {conn.protocol_type} not supported"
-        self._streams.add(conn.id)
+            f"{self._config_path}: {conn}: {conn.protocol_type} not supported"
+        self.add_stream(conn, conn.id, StreamType.SOCKET)
 
     def do_send(self, send: Send) -> None:
         self.assert_proc(send)
-        self.assert_stream(send, send.id)
+        self.assert_stream(send, send.id, StreamType.SOCKET)
 
     def do_recv(self, recv: Recv) -> None:
         self.assert_proc(recv)
-        self.assert_stream(recv, recv.id)
+        self.assert_stream(recv, recv.id, StreamType.SOCKET)
 
     def do_cleanup(self, successful: bool) -> None:
         if successful:

test-runner/wasi_test_runner/test_suite_runner.py

@@ -28,40 +28,6 @@ class Manifest(NamedTuple):
     wasi_version: WasiVersion
 
 
-class ArgvExtractor(TestCaseRunnerBase):
-    _test_path: str
-    _wasi_version: WasiVersion
-    _runtime: RuntimeAdapter
-    _argv: List[str]
-
-    def __init__(self, config: Config, test_path: str,
-                 wasi_version: WasiVersion, runtime: RuntimeAdapter) -> None:
-        TestCaseRunnerBase.__init__(self, config)
-        self._test_path = test_path
-        self._wasi_version = wasi_version
-        self._runtime = runtime
-        self._argv = []
-
-    def do_run(self, run: Run) -> None:
-        proposals = self.config.proposals_as_str()
-        self._argv = self._runtime.compute_argv(
-            self._test_path, run.args, run.env, run.dirs, proposals,
-            self._wasi_version)
-
-    # pylint: disable-msg=multiple-statements
-    def do_read(self, read: Read) -> None: pass
-    def do_write(self, write: Write) -> None: pass
-    def do_wait(self, wait: Wait) -> None: pass
-    def do_connect(self, conn: Connect) -> None: pass
-    def do_send(self, send: Send) -> None: pass
-    def do_recv(self, recv: Recv) -> None: pass
-    def do_cleanup(self, successful: bool) -> None: pass
-
-    def extract(self) -> List[str]:
-        self.run()
-        return self._argv
-
-
 class TestCaseRunner(TestCaseRunnerBase):
     # pylint: disable-msg=too-many-instance-attributes
     _test_path: str
@@ -250,7 +216,7 @@ def run_tests_from_test_suite(
             # useful to make reporters report it.
             skip, _ = filt.should_skip(meta, test_name)
             if skip:
-                test_case = _skip_single_test(runtime, meta, test_path)
+                test_case = _skip_single_test(test_path)
                 break
         else:
             test_case = _execute_single_test(runtime, meta, test_path)
@@ -268,16 +234,11 @@ def run_tests_from_test_suite(
     )
 
 
-def _skip_single_test(
-    runtime: RuntimeAdapter, meta: TestSuiteMeta, test_path: str
-) -> TestCase:
+def _skip_single_test(test_path: str) -> TestCase:
     config = _read_test_config(test_path)
-    argv = ArgvExtractor(
-        config, test_path, meta.wasi_version, runtime).extract()
-
     return TestCase(
         name=os.path.splitext(os.path.basename(test_path))[0],
-        argv=argv,
+        argv=[],
         config=config,
         result=Result(is_executed=False, failures=[]),
         duration_s=0,