atlas-init 0.3.7__py3-none-any.whl → 0.4.0__py3-none-any.whl

atlas_init/__init__.py

@@ -1,6 +1,6 @@
 from pathlib import Path
 
-VERSION = "0.3.7"
+VERSION = "0.4.0"
 
 
 def running_in_repo() -> bool:

atlas_init/atlas_init.yaml

@@ -91,3 +91,12 @@ test_suites:
   vars:
     cluster_info_m10: true
     stream_instance: true
+- name: trigger
+  repo_go_packages:
+    cfn:
+    - cfn-resources/trigger
+  vars:
+    cluster_info_m10: true
+  post_apply_hooks:
+  - name: create_realm_resources
+    locate: atlas_init.cli_root.trigger.create_realm_app

atlas_init/cli.py

@@ -40,7 +40,7 @@ from atlas_init.repos.path import (
     find_paths,
     resource_name,
 )
-from atlas_init.settings.config import RepoAliasNotFoundError
+from atlas_init.settings.config import RepoAliasNotFoundError, TestSuite
 from atlas_init.settings.env_vars import (
     active_suites,
     init_settings,
@@ -70,10 +70,15 @@ def plan(context: typer.Context, *, skip_outputs: bool = False):
 
 @app_command()
 def apply(context: typer.Context, *, skip_outputs: bool = False):
-    _plan_or_apply(context.args, "apply", skip_outputs=skip_outputs)
+    suites = _plan_or_apply(context.args, "apply", skip_outputs=skip_outputs)
+    for suite in suites:
+        for hook in suite.post_apply_hooks:
+            logger.info(f"running post apply hook: {hook.name}")
+            hook_func = locate(hook.locate)
+            hook_func()  # type: ignore
 
 
-def _plan_or_apply(extra_args: list[str], command: Literal["plan", "apply"], *, skip_outputs: bool):
+def _plan_or_apply(extra_args: list[str], command: Literal["plan", "apply"], *, skip_outputs: bool) -> list[TestSuite]:
     settings = init_settings()
     logger.info(f"using the '{command}' command, extra args: {extra_args}")
     try:
@@ -97,6 +102,7 @@ def _plan_or_apply(extra_args: list[str], command: Literal["plan", "apply"], *,
     if settings.env_vars_generated.exists():
         dump_vscode_dotenv(settings.env_vars_generated, settings.env_vars_vs_code)
         logger.info(f"your .env file is ready @ {settings.env_vars_vs_code}")
+    return suites
 
 
 @app_command()

atlas_init/cli_cfn/app.py

@@ -2,7 +2,6 @@ import logging
 import os
 
 import typer
-from model_lib import parse_payload
 from zero_3rdparty.file_utils import clean_dir
 
 from atlas_init.cli_cfn.aws import (
@@ -18,8 +17,13 @@ from atlas_init.cli_cfn.aws import (
 from atlas_init.cli_cfn.cfn_parameter_finder import (
     read_execution_role,
 )
+from atlas_init.cli_cfn.contract import contract_test_cmd
 from atlas_init.cli_cfn.example import example_cmd
-from atlas_init.cli_cfn.files import create_sample_file, has_md_link, iterate_schemas
+from atlas_init.cli_cfn.files import (
+    create_sample_file_from_input,
+    has_md_link,
+    iterate_schemas,
+)
 from atlas_init.cli_helper.run import run_command_is_ok
 from atlas_init.cloud.aws import run_in_regions
 from atlas_init.repos.cfn import (
@@ -30,6 +34,7 @@ from atlas_init.settings.env_vars import active_suites, init_settings
 
 app = typer.Typer(no_args_is_help=True)
 app.command(name="example")(example_cmd)
+app.command(name="contract-test")(contract_test_cmd)
 logger = logging.getLogger(__name__)
 
 
@@ -51,7 +56,7 @@ def reg(
             deregister_cfn_resource_type(type_name, deregister=not dry_run, region_filter=region)
     logger.info(f"ready to activate {type_name}")
     settings = init_settings()
-    cfn_execution_role = read_execution_role(settings.load_env_vars_generated())
+    cfn_execution_role = read_execution_role(settings.load_env_vars_full())
     last_third_party = get_last_cfn_type(type_name, region, is_third_party=True)
     assert last_third_party, f"no 3rd party extension found for {type_name} in {region}"
     if dry_run:
@@ -97,7 +102,7 @@ def inputs(
     cwd = current_dir()
     suite = suites[0]
     assert suite.cwd_is_repo_go_pkg(cwd, repo_alias="cfn")
-    env_extra = settings.load_env_vars_generated()
+    env_extra = settings.load_env_vars_full()
     CREATE_FILENAME = "cfn-test-create-inputs.sh"  # noqa: N806
     create_dirs = ["test/contract-testing", "test"]
     parent_dir = None
@@ -109,7 +114,7 @@ def inputs(
     assert parent_dir, f"unable to find a {CREATE_FILENAME} in {create_dirs} in {cwd}"
     if not run_command_is_ok(
         cwd=cwd,
-        cmd=[f"./{parent_dir}/{CREATE_FILENAME}", *context.args],
+        cmd=f"./{parent_dir}/{CREATE_FILENAME}" + " ".join(context.args),
         env={**os.environ} | env_extra,
         logger=logger,
     ):
@@ -131,20 +136,7 @@ def inputs(
         logger.info(f"input exist at inputs/{file.name} ✅")
         if skip_samples:
             continue
-        resource_state = parse_payload(file)
-        assert isinstance(resource_state, dict), f"input file with not a dict {resource_state}"
-        samples_file = samples_dir / file.name
-        if file.name.endswith("_create.json"):
-            create_sample_file(samples_file, log_group_name, resource_state)
-        if file.name.endswith("_update.json"):
-            prev_state_path = file.parent / file.name.replace("_update.json", "_create.json")
-            prev_state: dict = parse_payload(prev_state_path)  # type: ignore
-            create_sample_file(
-                samples_file,
-                log_group_name,
-                resource_state,
-                prev_resource_state=prev_state,
-            )
+        create_sample_file_from_input(samples_dir, log_group_name, file)
     if single_input:
         for file in sorted(inputs_dir.glob("*.json")):
             new_name = file.name.replace(expected_input, "inputs_1")

atlas_init/cli_cfn/aws.py

@@ -436,7 +436,7 @@ def ensure_resource_type_activated(
             default=True,
         )
     ):
-        assert run_command_is_ok(cmd=submit_cmd.split(), env=None, cwd=resource_path, logger=logger)
+        assert run_command_is_ok(cmd=submit_cmd, env=None, cwd=resource_path, logger=logger)
         cfn_type_details = get_last_cfn_type(type_name, region, is_third_party=False)
     if cfn_type_details is None:
         third_party = get_last_cfn_type(type_name, region, is_third_party=True, force_version=force_version)

atlas_init/cli_cfn/contract.py

@@ -0,0 +1,227 @@
+import logging
+import os
+import re
+from pathlib import Path
+
+import typer
+from model_lib import Entity
+from pydantic import Field
+from zero_3rdparty.file_utils import ensure_parents_write_text
+
+from atlas_init.cli_cfn.files import create_sample_file_from_input
+from atlas_init.cli_helper.run import (
+    run_binary_command_is_ok,
+)
+from atlas_init.cli_helper.run_manager import RunManager
+from atlas_init.cli_root import is_dry_run
+from atlas_init.repos.path import Repo, ResourcePaths, find_paths
+from atlas_init.settings.env_vars import AtlasInitSettings, init_settings
+
+logger = logging.getLogger(__name__)
+
+
+class RunContractTest(Entity):
+    resource_path: Path
+    repo_path: Path
+    cfn_region: str
+    aws_profile: str
+    skip_build: bool = False
+    dry_run: bool = Field(default_factory=is_dry_run)
+    only_names: list[str] | None = None
+
+    @property
+    def run_tests_command(self) -> tuple[str, str]:
+        if self.only_names:
+            names = " ".join(f"-k {name}" for name in self.only_names)
+            return (
+                "cfn",
+                f"test --function-name TestEntrypoint --verbose --region {self.cfn_region} -- {names}",
+            )
+        return (
+            "cfn",
+            f"test --function-name TestEntrypoint --verbose --region {self.cfn_region}",
+        )
+
+
+class RunContractTestOutput(Entity):
+    sam_local_logs: str
+    sam_local_exit_code: int
+    contract_test_ok: bool
+    rpdk_log: str
+
+
+class CreateContractTestInputs(Entity):
+    resource_path: Path
+    env_vars_generated: dict[str, str]
+    log_group_name: str
+
+
+class CFNBuild(Entity):
+    resource_path: Path
+    dry_run: bool = Field(default_factory=is_dry_run)
+    is_debug: bool = False
+    tags: str = "logging callback metrics scheduler"
+    cgo: int = 0
+    goarch: str = "amd64"
+    goos: str = "linux"
+    git_sha: str = "local"
+    ldflags: str = "-s -w -X github.com/mongodb/mongodbatlas-cloudformation-resources/util.defaultLogLevel=info -X github.com/mongodb/mongodbatlas-cloudformation-resources/version.Version=${CFNREP_GIT_SHA}"
+
+    @property
+    def extra_env(self) -> dict[str, str]:
+        return {"GOOS": self.goos, "CGO_ENABLED": str(self.cgo), "GOARCH": self.goarch}
+
+    @property
+    def flags(self) -> str:
+        return self.ldflags.replace("${CFNREP_GIT_SHA}", self.git_sha)
+
+    @property
+    def command_build(self) -> str:
+        return f'build -ldflags="{self.flags}" -tags="{self.tags}" -o bin/bootstrap cmd/main.go'
+
+    @property
+    def cfn_generate(self) -> str:
+        return "generate"
+
+    @property
+    def commands(self) -> list[tuple[str, str]]:
+        return [
+            ("cfn", self.cfn_generate),
+            ("go", self.command_build),
+        ]
+
+
+def contract_test_cmd(
+    only_names: list[str] = typer.Option(None, "-n", "--only-names", help="only run these contract tests"),
+):
+    result = contract_test(only_names=only_names)
+    if result.contract_test_ok:
+        logger.info("contract tests passed 🥳")
+    else:
+        logger.error("contract tests failed 💥")
+        logger.error(
+            f"function logs (exit_code={result.sam_local_exit_code}):\n {result.sam_local_logs}\n\nRPDK logs:\n{result.rpdk_log[-10_000:]}"
+        )
+        raise typer.Exit(1)
+    return result
+
+
+def contract_test(
+    settings: AtlasInitSettings | None = None,
+    resource_paths: ResourcePaths | None = None,
+    only_names: list[str] | None = None,
+):
+    settings = settings or init_settings()
+    resource_paths = resource_paths or find_paths(Repo.CFN)
+    resource_name = resource_paths.resource_name
+    generated_env_vars = settings.load_env_vars_full()
+    create_inputs = CreateContractTestInputs(
+        resource_path=resource_paths.resource_path,
+        env_vars_generated=generated_env_vars,
+        log_group_name=f"mongodb-atlas-{resource_name}-logs",
+    )
+    create_response = create_contract_test_inputs(create_inputs)
+    create_response.log_input_files(logger)
+    run_contract_test = RunContractTest(
+        resource_path=resource_paths.resource_path,
+        repo_path=resource_paths.repo_path,
+        aws_profile=settings.AWS_PROFILE,
+        cfn_region=settings.cfn_region,
+        only_names=only_names,
+    )
+    if run_contract_test.skip_build:
+        logger.info("skipping build")
+    else:
+        build_event = CFNBuild(resource_path=resource_paths.resource_path)
+        build(build_event)
+        logger.info("build ok ✅")
+    return run_contract_tests(run_contract_test)
+
+
+class CreateContractTestInputsResponse(Entity):
+    input_files: list[Path]
+    sample_files: list[Path]
+
+    def log_input_files(self, logger: logging.Logger):
+        inputs = self.input_files
+        if not inputs:
+            logger.warning("no input files created")
+            return
+        inputs_dir = self.input_files[0].parent
+        logger.info(f"{len(inputs)} inputs created in '{inputs_dir}'")
+        logger.info("\n".join(f"'{file.name}'" for file in self.input_files))
+
+
+def create_contract_test_inputs(
+    event: CreateContractTestInputs,
+) -> CreateContractTestInputsResponse:
+    inputs_dir = event.resource_path / "inputs"
+    samples_dir = event.resource_path / "samples"
+    test_dir = event.resource_path / "test"
+    sample_files = []
+    input_files = []
+    for template in sorted(test_dir.glob("*.template.json")):
+        template_file = template.read_text()
+        template_file = file_replacements(template_file, event.env_vars_generated, template.name)
+        inputs_file = inputs_dir / template.name.replace(".template", "")
+        ensure_parents_write_text(inputs_file, template_file)
+        input_files.append(inputs_file)
+        sample_file = create_sample_file_from_input(samples_dir, event.log_group_name, inputs_file)
+        sample_files.append(sample_file)
+    return CreateContractTestInputsResponse(input_files=input_files, sample_files=sample_files)
+
+
+def file_replacements(text: str, replacements: dict[str, str], file_name: str) -> str:
+    for match in re.finditer(r"\${(\w+)}", text):
+        var_name = match.group(1)
+        if var_name in replacements:
+            text = text.replace(match.group(0), replacements[var_name])
+        else:
+            logger.warning(f"found placeholder {match.group(0)} in {file_name} but no replacement")
+    return text
+
+
+def build(event: CFNBuild):
+    for binary, command in event.commands:
+        is_ok = run_binary_command_is_ok(
+            binary,
+            command,
+            cwd=event.resource_path,
+            logger=logger,
+            dry_run=event.dry_run,
+            env={**os.environ, **event.extra_env},
+        )
+        if not is_ok:
+            logger.critical(f"failed to run {binary} {command}")
+            raise typer.Exit(1)
+
+
+def run_contract_tests(event: RunContractTest) -> RunContractTestOutput:
+    with RunManager(dry_run=event.dry_run) as manager:
+        manager.set_timeouts(3)
+        resource_path = event.resource_path
+        run_future = manager.run_process_wait_on_log(
+            f"local start-lambda --skip-pull-image --region {event.cfn_region}",
+            binary="sam",
+            cwd=resource_path,
+            logger=logger,
+            line_in_log="Running on http://",
+            timeout=60,
+        )
+        binary, test_cmd = event.run_tests_command
+        test_result_ok = run_binary_command_is_ok(
+            binary,
+            test_cmd,
+            cwd=resource_path,
+            logger=logger,
+            dry_run=event.dry_run,
+        )
+        extra_log = resource_path / "rpdk.log"
+        log_content = extra_log.read_text() if extra_log.exists() else ""
+    sam_local_result = run_future.result(timeout=1)
+    return RunContractTestOutput(
+        sam_local_logs=sam_local_result.result_str,
+        sam_local_exit_code=sam_local_result.exit_code or -1,
+        contract_test_ok=test_result_ok,
+        rpdk_log=log_content,
+    )

atlas_init/cli_cfn/example.py

@@ -53,6 +53,9 @@ class CfnExampleInputs(CfnType):
         assert self.region_filter, "region is required"
         assert self.execution_role.startswith("arn:aws:iam::"), f"invalid execution role: {self.execution_role}"
         assert self.region
+        if self.delete_stack_first and self.operation == Operation.UPDATE:
+            err_msg = "cannot delete first when updating"
+            raise ValueError(err_msg)
         return self
 
     @property
@@ -76,7 +79,11 @@ def example_cmd(
     operation: str = typer.Argument(...),
     example_name: str = typer.Option("", "-e", "--example-name", help="example filestem"),
     resource_params: list[str] = typer.Option(
-        ..., "-r", "--resource-param", default_factory=list, help="key=value, can be set many times"
+        ...,
+        "-r",
+        "--resource-param",
+        default_factory=list,
+        help="key=value, can be set many times",
     ),
     stack_timeout_s: int = typer.Option(3600, "-t", "--stack-timeout-s"),
     delete_first: bool = typer.Option(False, "-d", "--delete-first", help="Delete existing stack first"),
@@ -93,9 +100,9 @@ def example_cmd(
     register_all_types_in_example: bool = typer.Option(False, "--reg-all", help="Check all types"),
 ):
     settings = init_settings()
-    assert settings.cfn_config, "no cfn config found, re-run atlas_init apply with CFN flags"
+    assert settings.tf_vars, "no cfn config found, re-run atlas_init apply with CFN flags"
     repo_path, resource_path, _ = find_paths(Repo.CFN)
-    env_vars_generated = settings.load_env_vars_generated()
+    env_vars_generated = settings.load_env_vars_full()
     inputs = CfnExampleInputs(
         type_name=type_name or infer_cfn_type_name(),
         example_name=example_name,
@@ -116,13 +123,18 @@ def example_cmd(
     example_handler(inputs, repo_path, resource_path, settings)
 
 
-def example_handler(inputs: CfnExampleInputs, repo_path: Path, resource_path: Path, settings: AtlasInitSettings):
+def example_handler(
+    inputs: CfnExampleInputs,
+    repo_path: Path,
+    resource_path: Path,
+    settings: AtlasInitSettings,
+):
     logger.info(
         f"about to {inputs.operation} stack {inputs.stack_name} for {inputs.type_name} in {inputs.region_filter} params: {inputs.resource_params}"
     )
     type_name = inputs.type_name
     stack_name = inputs.stack_name
-    env_vars_generated = settings.load_env_vars_generated()
+    env_vars_generated = settings.load_env_vars_full()
     region = inputs.region
     operation = inputs.operation
     stack_timeout_s = inputs.stack_timeout_s

atlas_init/cli_cfn/files.py

@@ -5,19 +5,37 @@ from collections.abc import Iterable
 from pathlib import Path
 
 import stringcase
-from model_lib import Entity, dump, parse_model
+from model_lib import Entity, dump, parse_model, parse_payload
 from pydantic import ConfigDict, Field, ValidationError
 from zero_3rdparty import file_utils
 
 logger = logging.getLogger(__name__)
 
 
+def create_sample_file_from_input(samples_dir: Path, log_group_name: str, inputs_file: Path) -> Path:
+    resource_state = parse_payload(inputs_file)
+    assert isinstance(resource_state, dict), f"input file with not a dict {resource_state}"
+    samples_file = samples_dir / inputs_file.name
+    if inputs_file.name.endswith("_create.json"):
+        return create_sample_file(samples_file, log_group_name, resource_state)
+    if inputs_file.name.endswith("_update.json"):
+        prev_state_path = inputs_file.parent / inputs_file.name.replace("_update.json", "_create.json")
+        prev_state: dict = parse_payload(prev_state_path)  # type: ignore
+        return create_sample_file(
+            samples_file,
+            log_group_name,
+            resource_state,
+            prev_resource_state=prev_state,
+        )
+    raise ValueError(f"unexpected input file {inputs_file}")
+
+
 def create_sample_file(
     samples_file: Path,
     log_group_name: str,
     resource_state: dict,
     prev_resource_state: dict | None = None,
-):
+) -> Path:
     logger.info(f"adding sample @ {samples_file}")
     assert isinstance(resource_state, dict)
     new_json = dump(
@@ -29,6 +47,7 @@ def create_sample_file(
         "pretty_json",
     )
     file_utils.ensure_parents_write_text(samples_file, new_json)
+    return samples_file
 
 
 CamelAlias = ConfigDict(alias_generator=stringcase.camelcase, populate_by_name=True)

atlas_init/cli_helper/go.py

@@ -67,8 +67,9 @@ def run_go_tests(
     re_run: bool = False,
     env_vars: GoEnvVars = GoEnvVars.vscode,
     names: set[str] | None = None,
+    use_replay_mode: bool = False,
 ) -> GoTestResult:
-    test_env = _resolve_env_vars(settings, env_vars)
+    test_env = _resolve_env_vars(settings, env_vars, use_replay_mode=use_replay_mode)
     if ci_value := test_env.pop("CI", None):
         logger.warning(f"pooped CI={ci_value}")
     results = GoTestResult()
@@ -115,14 +116,16 @@ def run_go_tests(
     )
 
 
-def _resolve_env_vars(settings: AtlasInitSettings, env_vars: GoEnvVars) -> dict[str, str]:
+def _resolve_env_vars(settings: AtlasInitSettings, env_vars: GoEnvVars, *, use_replay_mode: bool) -> dict[str, str]:
     if env_vars == GoEnvVars.manual:
         extra_vars = settings.load_profile_manual_env_vars(skip_os_update=True)
     elif env_vars == GoEnvVars.vscode:
         extra_vars = settings.load_env_vars(settings.env_vars_vs_code)
     else:
         raise NotImplementedError(f"don't know how to load env_vars={env_vars}")
-    test_env = os.environ | extra_vars | {"TF_ACC": "1", "TF_LOG": "DEBUG"}
+    mocker_env_name = "HTTP_MOCKER_REPLAY" if use_replay_mode else "HTTP_MOCKER_CAPTURE"
+    extra_vars |= {"TF_ACC": "1", "TF_LOG": "DEBUG", mocker_env_name: "true"}
+    test_env = os.environ | extra_vars
     logger.info(f"go test env-vars-extra: {sorted(extra_vars)}")
     return test_env
 

atlas_init/cli_helper/run.py

@@ -5,24 +5,27 @@ from logging import Logger
 from pathlib import Path
 from shutil import which
 from tempfile import TemporaryDirectory
-from typing import IO, TypeVar
+from typing import IO
 
 import typer
 from zero_3rdparty.id_creator import simple_id
 
-StrT = TypeVar("StrT", bound=str)
+LOG_CMD_PREFIX = "running: '"
 
 
 def run_command_is_ok(
-    cmd: list[StrT],
+    cmd: str,
     env: dict | None,
     cwd: Path | str,
     logger: Logger,
     output: IO | None = None,
+    *,
+    dry_run: bool = False,
 ) -> bool:
     env = env or {**os.environ}
-    command_str = " ".join(cmd)
-    logger.info(f"running: '{command_str}' from '{cwd}'")
+    logger.info(f"{LOG_CMD_PREFIX}{cmd}' from '{cwd}'")
+    if dry_run:
+        return True
     output = output or sys.stdout  # type: ignore
     exit_code = subprocess.call(
         cmd,
@@ -31,49 +34,44 @@ def run_command_is_ok(
         stdout=output,
         cwd=cwd,
         env=env,
+        shell=True,  # noqa: S602 # We control the calls to this function and don't suspect any shell injection
     )
     is_ok = exit_code == 0
     if is_ok:
-        logger.info(f"success 🥳 '{command_str}'\n")  # adds extra space to separate runs
+        logger.info(f"success 🥳 '{cmd}'\n")  # adds extra space to separate runs
     else:
-        logger.error(f"error 💥, exit code={exit_code}, '{command_str}'")
+        logger.error(f"error 💥, exit code={exit_code}, '{cmd}'")
     return is_ok
 
 
 def run_binary_command_is_ok(
-    binary_name: str, command: str, cwd: Path, logger: Logger, env: dict | None = None
+    binary_name: str, command: str, cwd: Path, logger: Logger, env: dict | None = None, *, dry_run: bool = False
 ) -> bool:
     env = env or {**os.environ}
-
-    bin_path = find_binary_on_path(binary_name, logger)
+    bin_path = find_binary_on_path(binary_name, logger, allow_missing=dry_run) or binary_name
     return run_command_is_ok(
-        [bin_path, *command.split()],
+        f"{bin_path} {command}",
         env=env,
         cwd=cwd,
         logger=logger,
+        dry_run=dry_run,
     )
 
 
 def find_binary_on_path(binary_name: str, logger: Logger, *, allow_missing: bool = False) -> str:
-    bin_path = which(binary_name)
-    if bin_path:
+    if bin_path := which(binary_name):
         return bin_path
     if allow_missing:
+        logger.warning(f"binary '{binary_name}' not found on $PATH")
         return ""
     logger.critical(f"please install '{binary_name}'")
     raise typer.Exit(1)
 
 
 def run_command_exit_on_failure(
-    cmd: list[StrT] | str,
-    cwd: Path | str,
-    logger: Logger,
-    env: dict | None = None,
+    cmd: str, cwd: Path | str, logger: Logger, env: dict | None = None, *, dry_run: bool = False
 ) -> None:
-    if isinstance(cmd, str):
-        cmd = cmd.split()  # type: ignore
-    assert isinstance(cmd, list)
-    if not run_command_is_ok(cmd, cwd=cwd, env=env, logger=logger):
+    if not run_command_is_ok(cmd, cwd=cwd, env=env, logger=logger, dry_run=dry_run):
         logger.critical("command failed, see output 👆")
         raise typer.Exit(1)
 
@@ -84,7 +82,7 @@ def run_command_receive_result(
     with TemporaryDirectory() as temp_dir:
         result_file = Path(temp_dir) / "file"
         with open(result_file, "w") as file:
-            is_ok = run_command_is_ok(command.split(), env=env, cwd=cwd, logger=logger, output=file)
+            is_ok = run_command_is_ok(command, env=env, cwd=cwd, logger=logger, output=file)
         output_text = result_file.read_text().strip()
     if not is_ok:
         if can_fail:
@@ -99,7 +97,7 @@ def run_command_is_ok_output(command: str, cwd: Path, logger: Logger, env: dict
     with TemporaryDirectory() as temp_dir:
         result_file = Path(temp_dir) / f"{simple_id()}.txt"
         with open(result_file, "w") as file:
-            is_ok = run_command_is_ok(command.split(), env=env, cwd=cwd, logger=logger, output=file)
+            is_ok = run_command_is_ok(command, env=env, cwd=cwd, logger=logger, output=file)
         output_text = result_file.read_text().strip()
     return is_ok, output_text