Rework "run vs serve" logic to require explicit wasi world

* adapters/pywasm.py:
* adapters/wasm-micro-runtime.py:
* adapters/wasmedge.py:
* adapters/wasmtime.py:
* adapters/wazero.py:
* adapters/wizard.py: Take a WASI world as an additional argument.
* test-runner/tests/test_test_case.py:
* test-runner/tests/test_test_suite_runner.py: Update tests.
* test-runner/wasi_test_runner/runtime_adapter.py: Plumb wasi_world
through to runtime.
* test-runner/wasi_test_runner/test_case.py (WasiWorld): New type.
(WasiProposal): Remove http/service, it's not a proposal.
(Config.from_file): Don't infer proposals from ops.  Parse out a world.
* test-runner/wasi_test_runner/test_suite_runner.py
(TestCaseRunner.do_run): Pass world to adapter.
* tests/rust/wasm32-wasip3/src/bin/http-service.json: Adapt.

Author: wingo

adapters/pywasm.py

@@ -27,9 +27,15 @@ def get_version() -> str:
 def get_wasi_versions() -> List[str]:
     return ["wasm32-wasip1"]
 
+
+def get_wasi_worlds() -> List[str]:
+    return ["wasi:cli/command"]
+
+
 def compute_argv(test_path: str,
                  args_env_dirs: Tuple[List[str], Dict[str, str], List[Tuple[Path, str]]],
                  proposals: List[str],
+                 wasi_world: str,
                  wasi_version: str) -> List[str]:
 
     argv = []

adapters/wasm-micro-runtime.py

@@ -28,9 +28,14 @@ def get_wasi_versions() -> List[str]:
     return ["wasm32-wasip1"]
 
 
+def get_wasi_worlds() -> List[str]:
+    return ["wasi:cli/command"]
+
+
 def compute_argv(test_path: str,
                  args_env_dirs: Tuple[List[str], Dict[str, str], List[Tuple[Path, str]]],
                  proposals: List[str],
+                 wasi_world: str,
                  wasi_version: str) -> List[str]:
 
     argv = []

adapters/wasmedge.py

@@ -28,9 +28,14 @@ def get_wasi_versions() -> List[str]:
     return ["wasm32-wasip1"]
 
 
+def get_wasi_worlds() -> List[str]:
+    return ["wasi:cli/command"]
+
+
 def compute_argv(test_path: str,
                  args_env_dirs: Tuple[List[str], Dict[str, str], List[Tuple[Path, str]]],
                  proposals: List[str],
+                 wasi_world: str,
                  wasi_version: str) -> List[str]:
 
     argv = []

adapters/wasmtime.py

@@ -25,9 +25,14 @@ def get_wasi_versions() -> List[str]:
     return ["wasm32-wasip1", "wasm32-wasip3"]
 
 
+def get_wasi_worlds() -> List[str]:
+    return ["wasi:cli/command", "wasi:http/service"]
+
+
 def compute_argv(test_path: str,
                  args_env_dirs: Tuple[List[str], Dict[str, str], List[Tuple[Path, str]]],
                  proposals: List[str],
+                 wasi_world: str,
                  wasi_version: str) -> List[str]:
 
     argv = []
@@ -43,17 +48,26 @@ def compute_argv(test_path: str,
     argv += [test_path]
 
     argv += args
-    _add_wasi_version_options(argv, wasi_version, proposals)
+    _add_wasi_version_options(argv, wasi_version, proposals, wasi_world)
     return argv
 
 
 # The user might provide WASMTIME="wasmtime --option -Sfoo".  Let's
 # insert the options to choose the WASI version before the user's
 # options, so that the user can override our choices.
-def _add_wasi_version_options(argv: List[str], wasi_version: str, proposals: List[str]) -> None:
+def _add_wasi_version_options(argv: List[str], wasi_version: str,
+                              proposals: List[str], wasi_world: str) -> None:
     splice_pos = len(WASMTIME)
     while splice_pos > 1 and argv[splice_pos - 1].startswith("-"):
         splice_pos -= 1
+    match wasi_world:
+        case "wasi:cli/command":
+            pass
+        case "wasi:http/service":
+            argv[splice_pos:splice_pos] = \
+                ["serve", "-Scli", "--addr=127.0.0.1:0"]
+            splice_pos += 1
+
     match wasi_version:
         case "wasm32-wasip1":
             pass
@@ -63,13 +77,6 @@ def _add_wasi_version_options(argv: List[str], wasi_version: str, proposals: Lis
                 flags_from_proposals += ",http"
             if "sockets" in proposals:
                 flags_from_proposals += ",inherit-network"
-            if "http/service" in proposals:
-                flags_from_proposals += ",cli"
-                argv[splice_pos:splice_pos] = ["serve", "--addr=127.0.0.1:0"]
-                splice_pos += 1
 
             argv[splice_pos:splice_pos] = ["-Wcomponent-model-async",
                                            f"-Sp3{flags_from_proposals}"]
-
-        case _:
-            pass

adapters/wazero.py

@@ -30,9 +30,14 @@ def get_wasi_versions() -> List[str]:
     return ["wasm32-wasip1"]
 
 
+def get_wasi_worlds() -> List[str]:
+    return ["wasi:cli/command"]
+
+
 def compute_argv(test_path: str,
                  args_env_dirs: Tuple[List[str], Dict[str, str], List[Tuple[Path, str]]],
                  proposals: List[str],
+                 wasi_world: str,
                  wasi_version: str) -> List[str]:
 
     argv = []

adapters/wizard.py

@@ -36,9 +36,14 @@ def get_wasi_versions() -> List[str]:
     return ["wasm32-wasip1"]
 
 
+def get_wasi_worlds() -> List[str]:
+    return ["wasi:cli/command"]
+
+
 def compute_argv(test_path: str,
                  args_env_dirs: Tuple[List[str], Dict[str, str], List[Tuple[Path, str]]],
                  proposals: List[str],
+                 wasi_world: str,
                  wasi_version: str) -> List[str]:
 
     argv = []

test-runner/tests/test_test_case.py

@@ -9,7 +9,7 @@
 from wasi_test_runner.test_case import (
     Config, Failure, Result,
     Run, Wait, Read, Write, Connect, Send, Recv, Request, Response, Kill,
-    ProtocolType, WasiProposal, TestCaseValidator
+    ProtocolType, WasiProposal, WasiWorld, TestCaseValidator
 )
 
 
@@ -225,19 +225,21 @@ def test_new_config_with_empty_proposals(_mock_file: Mock) -> None:
     config = Config.from_file("file")
 
     assert len(config.proposals) == 0
+    assert config.world == WasiWorld.CLI_COMMAND
 
 
 @patch(
     "builtins.open",
     new_callable=mock_open,
-    read_data='{"operations": [{"type": "run"}], "proposals": ["http", "sockets"]}',
+    read_data='{"operations": [{"type": "run"}], "proposals": ["http", "sockets"], "world": "wasi:http/service"}',
 )
 def test_new_config_with_multiple_proposals(_mock_file: Mock) -> None:
     config = Config.from_file("file")
 
     assert len(config.proposals) == 2
     assert config.proposals[0] == WasiProposal.HTTP
     assert config.proposals[1] == WasiProposal.SOCKETS
+    assert config.world == WasiWorld.HTTP_SERVICE
 
 
 @patch(
@@ -250,6 +252,16 @@ def test_new_config_should_fail_with_invalid_proposal(_mock_file: Mock) -> None:
         Config.from_file("file")
 
 
+@patch(
+    "builtins.open",
+    new_callable=mock_open,
+    read_data='{"operations": [{"type": "run"}], world: "invalid"}',
+)
+def test_new_config_should_fail_with_invalid_world(_mock_file: Mock) -> None:
+    with pytest.raises(ValueError):
+        Config.from_file("file")
+
+
 def validate_config(config: Config) -> None:
     TestCaseValidator(config, 'test-config.json').validate()
 

test-runner/tests/test_test_suite_runner.py

@@ -17,7 +17,8 @@ def open_mock(filename: str, *_args: Any, **_kwargs: Any) -> Any:
             "my-path/test3.json": '{"stdout": "output", "env": {"x": "1"}}',
             "my-path/test4.json": (
                 '{"operations": [{"type": "run"}, {"type": "wait", "exit_code": 1}], '
-                '"proposals": []}'
+                '"proposals": [], '
+                '"world": "wasi:http/service"}'
             ),
         }
         if filename in file_content:
@@ -54,19 +55,23 @@ def test_runner_end_to_end() -> None:
                 tc.Run(dirs=[(Path(test_suite_dir) / d, d) for d in test_dirs]),
                 tc.Wait(exit_code=0)
             ],
-            proposals=[]
+            proposals=[],
+            world=tc.WasiWorld.CLI_COMMAND
         ),
         tc.Config(
             operations=[tc.Run(args=["a", "b"]), tc.Wait(exit_code=1)],
-            proposals=[]
+            proposals=[],
+            world=tc.WasiWorld.CLI_COMMAND
         ),
         tc.Config(
             operations=[tc.Run(env={"x": "1"}), tc.Read(id="stdout", payload="output"), tc.Wait(exit_code=0)],
-            proposals=[]
+            proposals=[],
+            world=tc.WasiWorld.CLI_COMMAND
         ),
         tc.Config(
             operations=[tc.Run(), tc.Wait(exit_code=1)],
-            proposals=[]
+            proposals=[],
+            world=tc.WasiWorld.HTTP_SERVICE
         ),
     ]
 

test-runner/wasi_test_runner/runtime_adapter.py

@@ -4,7 +4,7 @@
 from pathlib import Path
 from typing import NamedTuple, List, Tuple, Dict, Any
 
-from .test_case import WasiVersion
+from .test_case import WasiVersion, WasiWorld
 
 
 class RuntimeMeta(NamedTuple):
@@ -93,17 +93,20 @@ def get_meta(self) -> RuntimeMeta:
         return self._meta
 
     def compute_argv(self, test_path: str,
-                     args: List[str], env: Dict[str, str],
+                     args: List[str],
+                     env: Dict[str, str],
                      dirs: List[Tuple[Path, str]],
                      proposals: List[str],
+                     wasi_world: WasiWorld,
                      wasi_version: WasiVersion) -> List[str]:
         # too-many-positional-arguments is a post-3.0 pylint message.
         # pylint: disable-msg=unknown-option-value
         # pylint: disable-msg=too-many-arguments
         # pylint: disable-msg=too-many-positional-arguments
         args_env_dirs = [args, env, dirs]
         argv = self._adapter.compute_argv(test_path, args_env_dirs,
-                                          proposals, wasi_version.value)
+                                          proposals, wasi_world.value,
+                                          wasi_version.value)
         assert isinstance(argv, list)
         assert all(isinstance(arg, str) for arg in argv)
         return argv

test-runner/wasi_test_runner/test_case.py

@@ -7,14 +7,19 @@
 
 # Top level configuration keys
 LEGACY_CONFIG_KEYS = {"args", "dirs", "env", "exit_code", "stderr", "stdout"}
-CONFIG_KEYS = {"operations", "proposals"}
+CONFIG_KEYS = {"operations", "proposals", "world"}
 
 
 # Supported operations
 SUPPORTED_OPERATIONS = {"run", "wait", "read", "write", "connect",
                         "send", "recv", "request", "kill"}
 
 
+class WasiWorld(StrEnum):
+    CLI_COMMAND = 'wasi:cli/command'
+    HTTP_SERVICE = 'wasi:http/service'
+
+
 class WasiVersion(StrEnum):
     WASM32_WASIP1 = 'wasm32-wasip1'
     WASM32_WASIP2 = 'wasm32-wasip2'
@@ -243,29 +248,9 @@ def from_config(cls: Type[K], config: Dict[str, Any]) -> K:
 
 class WasiProposal(StrEnum):
     HTTP = 'http'
-    HTTP_SERVICE = 'http/service'
     SOCKETS = 'sockets'
 
 
-def _infer_proposals_from_operations(ops: List[Operation]) -> List[WasiProposal]:
-    sockets = False
-    http_service = False
-    for op in ops:
-        match op:
-            case Recv() | Send() | Connect():
-                sockets = True
-            case Request():
-                http_service = True
-            case _:
-                pass
-    ret = []
-    if sockets:
-        ret.append(WasiProposal.SOCKETS)
-    if http_service:
-        ret.append(WasiProposal.HTTP_SERVICE)
-    return ret
-
-
 T = TypeVar("T", bound="Config")
 
 
@@ -274,6 +259,7 @@ class Config(NamedTuple):
     operations: List[Operation] = [Run(), Wait()]
     # WASI proposals needed for the test.
     proposals: List[WasiProposal] = []
+    world: WasiWorld = WasiWorld.CLI_COMMAND
 
     @classmethod
     def from_file(cls: Type[T], config_file: str) -> T:
@@ -288,12 +274,16 @@ def from_file(cls: Type[T], config_file: str) -> T:
             if dict_config.get("operations") is not None:
                 operations = cls._operations_from_config(test_config_path, dict_config.get("operations"))
 
-            if dict_config.get("proposals") is None:
-                proposals = _infer_proposals_from_operations(operations)
-            else:
+            proposals = []
+            if dict_config.get("proposals") is not None:
                 proposals = cls._proposals_from_config(dict_config.get("proposals"))
 
-            return cls(operations=operations, proposals=proposals)
+            world = dict_config.get("world", WasiWorld.CLI_COMMAND.value)
+            if world not in WasiWorld:
+                raise ValueError(f"Unknown WASI world: {world}")
+
+            return cls(operations=operations, proposals=proposals,
+                       world=WasiWorld(world))
 
         cls._validate_config(dict_config, LEGACY_CONFIG_KEYS)
 
@@ -328,6 +318,7 @@ def from_file(cls: Type[T], config_file: str) -> T:
             # reliable, plus we'd be introducing a third level of
             # configuration.
             proposals=[],
+            world=WasiWorld.CLI_COMMAND
         )
 
     def proposals_as_str(self) -> List[str]: