Add tool install --missing and tool upgrade --all

Author: simu

commodore/cli/tool.py

@@ -58,9 +58,21 @@ def tool_list(config: Config, verbose: int, github_token: str, version_check: bo
     help="A version to install for the requested tool. "
     + "By default, the latest version is installed.",
 )
-@click.argument("tool")
+@click.option(
+    "--missing",
+    is_flag=True,
+    default=False,
+    help="Install the latest version for all currently unmanaged tools. "
+    + "This flag and providing a tool name on the command line are mutually exclusive.",
+)
+@click.argument("tool", required=False, default="")
 def tool_install(
-    config: Config, verbose: int, tool: str, version: Optional[str], github_token: str
+    config: Config,
+    verbose: int,
+    tool: str,
+    version: Optional[str],
+    github_token: str,
+    missing: bool,
 ):
     """Install one of the required tools in `$XDG_CACHE_DIR/commodore/tools`.
 
@@ -73,10 +85,28 @@ def tool_install(
 
     Optionally, the command accepts a tool version to install. The command
     accepts versions prefixed  with "v" and unprefixed versions.
+
+    Alternatively, the command can install the latest version for all required
+    tools which aren't managed by Commodore yet by passing flag --all. This flag
+    is mutually exclusive with providing a tool name.
     """
     config.update_verbosity(verbose)
     config.github_token = github_token
-    tools.install_tool(config, tool, version)
+
+    if not tool and not missing or tool and missing:
+        raise click.ClickException(
+            "`commodore install tool` expects to be called with either a tool name or the `--missing` flag."
+        )
+    if missing and version:
+        click.secho(
+            "Flag `--version` has no effect when calling the command with `--missing`.",
+            fg="yellow",
+        )
+
+    if missing:
+        tools.install_missing_tools(config)
+    else:
+        tools.install_tool(config, tool, version)
 
 
 @tool_group.command(name="upgrade", short_help="Upgrade external tools")
@@ -90,9 +120,21 @@ def tool_install(
     help="A version to upgrade (or downgrade) to for the requested tool. "
     + "By default, the tool is upgraded to the latest version.",
 )
-@click.argument("tool")
+@click.option(
+    "--all",
+    is_flag=True,
+    default=False,
+    help="Upgrade all currently managed tools to their latest versions. "
+    + "This flag and providing a tool name on the command line are mutually exclusive.",
+)
+@click.argument("tool", required=False, default="")
 def tool_upgrade(
-    config: Config, verbose: int, tool: str, version: Optional[str], github_token: str
+    config: Config,
+    verbose: int,
+    tool: str,
+    version: Optional[str],
+    github_token: str,
+    all: bool,
 ):
     """Upgrade (or downgrade) one of the required tools in `$XDG_CACHE_DIR/commodore/tools`.
 
@@ -106,7 +148,24 @@ def tool_upgrade(
 
     Optionally, the command accepts a tool version to upgrade (or downgrade) to.
     The command accepts versions prefixed with "v" and unprefixed versions.
+
+    Alternatively, the command can upgrade all managed tools to their latest
+    versions by passing flag --all. This flag is mutually exclusive with
+    providing a tool name.
     """
     config.update_verbosity(verbose)
     config.github_token = github_token
-    tools.upgrade_tool(config, tool, version)
+
+    if not tool and not all or tool and all:
+        raise click.ClickException(
+            "`commodore upgrade tool` expects to be called with either a tool name or the `--all` flag."
+        )
+    if all and version:
+        click.secho(
+            "Flag `--version` has no effect when calling the command with `--all`.",
+            fg="yellow",
+        )
+    if all:
+        tools.upgrade_all_tools(config)
+    else:
+        tools.upgrade_tool(config, tool, version)

commodore/tools.py

@@ -304,15 +304,25 @@ def install_tool(config: Config, tool: str, version: Optional[str]):
     do_install(config, tool, version)
 
 
-def upgrade_tool(config: Config, tool: str, version: Optional[str]):
-    check_known(tool)
-    if tool not in config.managed_tools:
+def install_missing_tools(config: Config):
+    MANAGED_TOOLS_PATH.mkdir(parents=True, exist_ok=True)
+    missing_tools = set(REQUIRED_TOOLS) - set(config.managed_tools.keys())
+    if len(missing_tools) == 0:
         click.echo(
-            f"Tool {tool} not installed yet. "
-            + f"Use `commodore tool install {tool}` to install tools."
+            "All required tools are already managed by Commodore.\n\n"
+            + "Use `commodore tool upgrade --all` to upgrade all tools to their latest versions."
         )
         return
 
+    for tool in sorted(REQUIRED_TOOLS):
+        if tool in config.managed_tools:
+            click.secho(f"Tool {tool} already managed, skipping...", fg="yellow")
+            continue
+        click.secho(f"Installing tool {tool}", bold=True)
+        do_install(config, tool, None)
+
+
+def do_upgrade(config: Config, tool: str, version: Optional[str]):
     # The kustomize install script is unhappy if the kustomize binary is already
     # present in the install directory. To keep it simple, we unlink the old
     # tool binary for all tools when doing an upgrade (note that this generates
@@ -326,3 +336,31 @@ def upgrade_tool(config: Config, tool: str, version: Optional[str]):
         if tool_path.parent == MANAGED_TOOLS_PATH:
             tool_path.unlink()
     do_install(config, tool, version)
+
+
+def upgrade_tool(config: Config, tool: str, version: Optional[str]):
+    check_known(tool)
+    if tool not in config.managed_tools:
+        click.echo(
+            f"Tool {tool} not installed yet. "
+            + f"Use `commodore tool install {tool}` to install tools."
+        )
+        return
+
+    do_upgrade(config, tool, version)
+
+
+def upgrade_all_tools(config: Config):
+    if len(config.managed_tools) == 0:
+        click.echo(
+            "No tools managed by Commodore yet.\n\n"
+            + "Use `commodore tool install --missing` to install the latest version for all required tools."
+        )
+        return
+
+    for tool in sorted(REQUIRED_TOOLS):
+        if tool not in config.managed_tools:
+            click.secho(f"Tool {tool} not managed, skipping...", fg="yellow")
+            continue
+        click.secho(f"Upgrading tool {tool}", bold=True)
+        do_upgrade(config, tool, None)

docs/modules/ROOT/pages/reference/cli.adoc

@@ -675,6 +675,9 @@ However, labels added by previous runs can't be removed since we've got no easy
   Specify a version to install for the requested tool.
   By default, the latest version is installed.
 
+*--missing*::
+  Install the latest version for all currently unmanaged tools.
+  This flag and providing a tool name on the command line are mutually exclusive.
 
 == Tool Upgrade
 
@@ -686,6 +689,10 @@ However, labels added by previous runs can't be removed since we've got no easy
   Specify a custom version to upgrade (or downgrade) to for the requested tool.
   By default, tools are upgraded to the latest version.
 
+*--all*::
+  Upgrade all currently managed tools to their latest versions.
+  This flag and providing a tool name on the command line are mutually exclusive.
+
 == Version
 
 Show extended version information for Commodore.

docs/modules/ROOT/pages/reference/commands.adoc

@@ -304,12 +304,16 @@ For `jb`, the command directly downloads the requested version from the GitHub r
 Optionally, the command accepts a tool version to install.
 The command accepts versions prefixed  with "v" and unprefixed versions.
 
+  commodore tool install --missing
+
+Install the latest version of each required tool which isn't managed by Commodore yet.
+This variant of the command doesn't accept a tool name or the `--version` flag.
+
 == Tool Upgrade
 
   commodore tool upgrade TOOL
 
 Upgrade (or downgrade) one of the required tools in `$XDG_CACHE_DIR/commodore/tools`.
-
 The command will fail for tools which aren't managed by Commodore yet.
 
 By default, the command will upgrade the tool to the latest available version.
@@ -319,6 +323,11 @@ For `jb`, the command directly downloads the requested version from the GitHub r
 Optionally, the command accepts a tool version to upgrade (or downgrade) to.
 The command accepts versions prefixed with "v" and unprefixed versions.
 
+  commodore tool upgrade --all
+
+Upgrade all tools which are managed by Commodore to their latest versions.
+This variant of the command doesn't accept a tool name or the `--version` flag.
+
 == Version
 
   commodore version

tests/test_cli_tool.py

@@ -64,6 +64,42 @@ def mock_install(_config: Config, mtool: str, mversion: Optional[str]):
     mock_load_state.assert_called_once()
 
 
+@patch("commodore.tools.install_missing_tools")
+@patch("commodore.tools.load_state")
+@pytest.mark.parametrize(
+    "args,exit_code,output",
+    [
+        ([], 0, ""),
+        (
+            ["--version", "1.2.3"],
+            0,
+            "Flag `--version` has no effect when calling the command with `--missing`",
+        ),
+        (
+            ["jb"],
+            1,
+            "`commodore install tool` expects to be called with either a tool name or the `--missing` flag.",
+        ),
+    ],
+)
+def test_tool_install_missing(
+    mock_load_state,
+    mock_install_missing_tools,
+    cli_runner: RunnerFunc,
+    args: list[str],
+    exit_code: int,
+    output: str,
+):
+    result = cli_runner(["tool", "install", "--missing"] + args)
+    assert result.exit_code == exit_code
+    assert output in result.output
+    if exit_code == 0:
+        mock_install_missing_tools.assert_called_once()
+    else:
+        mock_install_missing_tools.assert_not_called()
+    mock_load_state.assert_called_once()
+
+
 @patch("commodore.tools.upgrade_tool")
 @patch("commodore.tools.load_state")
 @pytest.mark.parametrize(
@@ -90,3 +126,39 @@ def mock_upgrade(_config: Config, mtool: str, mversion: Optional[str]):
     result = cli_runner(["tool", "upgrade", tool] + args)
     assert result.exit_code == 0
     mock_load_state.assert_called_once()
+
+
+@patch("commodore.tools.upgrade_all_tools")
+@patch("commodore.tools.load_state")
+@pytest.mark.parametrize(
+    "args,exit_code,output",
+    [
+        ([], 0, ""),
+        (
+            ["--version", "1.2.3"],
+            0,
+            "Flag `--version` has no effect when calling the command with `--all`",
+        ),
+        (
+            ["jb"],
+            1,
+            "`commodore upgrade tool` expects to be called with either a tool name or the `--all` flag.",
+        ),
+    ],
+)
+def test_tool_upgrade_all(
+    mock_load_state,
+    mock_upgrade_all_tools,
+    cli_runner: RunnerFunc,
+    args: list[str],
+    exit_code: int,
+    output: str,
+):
+    result = cli_runner(["tool", "upgrade", "--all"] + args)
+    assert result.exit_code == exit_code
+    assert output in result.output
+    if exit_code == 0:
+        mock_upgrade_all_tools.assert_called_once()
+    else:
+        mock_upgrade_all_tools.assert_not_called()
+    mock_load_state.assert_called_once()

tests/test_tools.py

@@ -468,6 +468,55 @@ def test_install_kustomize(config: Config, capfd, tmp_path, github_token):
     assert outlines[4] == f"GITHUB_TOKEN={github_token}"
 
 
+@patch.object(tools, "do_install")
+@pytest.mark.parametrize(
+    "managed,output",
+    [
+        (
+            {
+                "helm": "2025-07-11T11:04:40",
+                "jb": "2025-07-11T10:58:11",
+                "kustomize": "2025-07-11T11:05:05",
+            },
+            "All required tools are already managed by Commodore.\n\n"
+            + "Use `commodore tool upgrade --all` to upgrade all tools "
+            + "to their latest versions.\n",
+        ),
+        (
+            {"jb": "2025-07-11T10:58:11"},
+            "Installing tool helm\n"
+            + "Tool jb already managed, skipping...\n"
+            + "Installing tool kustomize\n",
+        ),
+    ],
+)
+def test_install_missing_tools(
+    mock_do_install: MagicMock,
+    config: Config,
+    capsys,
+    managed: dict[str, str],
+    output: str,
+):
+    config.managed_tools = managed
+
+    tools.install_missing_tools(config)
+
+    assert mock_do_install.call_count == len(tools.REQUIRED_TOOLS) - len(managed)
+
+    out, _ = capsys.readouterr()
+    assert out == output
+
+
+def test_install_script_invalid_version(config: Config):
+    with pytest.raises(ValueError) as exc:
+        tools.install_script(config, "jb", "v0.6.3")
+
+    assert (
+        str(exc.value)
+        == "Function install_script() expects parameter `version` to not be prefixed with 'v'."
+    )
+
+
 def test_upgrade_tool_not_installed(config: Config, capsys):
     config.managed_tools = {}
     tools.upgrade_tool(config, "jb", None)
@@ -510,3 +559,38 @@ def do_inst(_config: Config, tool: str, version: Optional[str]):
             tools.upgrade_tool(config, "jb", None)
 
     assert jb_file.exists() != managed_jb
+
+
+@patch.object(tools, "do_upgrade")
+@pytest.mark.parametrize(
+    "managed,output",
+    [
+        (
+            {},
+            "No tools managed by Commodore yet.\n\n"
+            + "Use `commodore tool install --missing` to install the latest "
+            + "version for all required tools.\n",
+        ),
+        (
+            {"jb": "2025-07-11T10:58:11"},
+            "Tool helm not managed, skipping...\n"
+            + "Upgrading tool jb\n"
+            + "Tool kustomize not managed, skipping...\n",
+        ),
+    ],
+)
+def test_upgrade_all_tools(
+    mock_do_upgrade: MagicMock,
+    config: Config,
+    capsys,
+    managed: dict[str, str],
+    output: str,
+):
+    config.managed_tools = managed
+
+    tools.upgrade_all_tools(config)
+
+    assert mock_do_upgrade.call_count == len(managed)
+
+    out, _ = capsys.readouterr()
+    assert out == output