Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

6.6 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

"""Tests for coding-agent CLI detection used by the API-keys settings panel."""

import os
import sys

import pytest

from subprocess import CompletedProcess
from unittest.mock import patch

from utils.coding_agents import (
    CODING_AGENTS,
    detect_installed_coding_agents,
    is_deepseek_harness_executable,
)


def test_matches_unsloth_start_subcommands():
    # Each entry must be a real unsloth start subcommand name; spelled out to avoid heavy imports
    assert CODING_AGENTS == (
        "claude",
        "codex",
        "vscode",
        "dsh",
        "opencode",
        "hermes",
        "openclaw",
        "pi",
        "vibe",
    )


def test_detects_vscode_by_its_code_launcher():
    with patch(
        "utils.coding_agents.shutil.which",
        side_effect = lambda name: "/usr/local/bin/code" if name == "code" else None,
    ):
        assert detect_installed_coding_agents() == ["vscode"]


def test_detects_only_agents_present_on_path():
    installed = {"claude", "opencode"}
    with patch(
        "utils.coding_agents.shutil.which",
        side_effect = lambda name: f"/usr/bin/{name}" if name in installed else None,
    ):
        assert detect_installed_coding_agents() == ["claude", "opencode"]


def test_returns_empty_list_when_nothing_is_installed():
    with patch("utils.coding_agents.shutil.which", return_value = None):
        assert detect_installed_coding_agents() == []


def test_preserves_declared_order_regardless_of_path_lookup_order():
    with patch(
        "utils.coding_agents.shutil.which",
        side_effect = lambda name: name if name in ("pi", "claude", "hermes") else None,
    ):
        assert detect_installed_coding_agents() == ["claude", "hermes", "pi"]


def test_treats_a_path_lookup_error_as_not_installed():
    def flaky_which(name: str):
        if name == "codex":
            raise OSError("permission denied")
        return name if name == "claude" else None

    with patch("utils.coding_agents.shutil.which", side_effect = flaky_which):
        assert detect_installed_coding_agents() == ["claude"]


def test_rejects_distributed_shell_as_deepseek_harness():
    with (
        patch(
            "utils.coding_agents.shutil.which",
            side_effect = lambda name, path = None: "/usr/bin/dsh" if name == "dsh" else None,
        ),
        patch("utils.coding_agents.is_deepseek_harness_executable", return_value = False),
    ):
        assert detect_installed_coding_agents() == []


def test_detects_harness_behind_an_unrelated_earlier_path_entry(monkeypatch):
    system_dir = os.path.abspath("system-bin")
    harness_dir = os.path.abspath("user-bin")
    monkeypatch.setenv("PATH", os.pathsep.join((system_dir, harness_dir)))

    def which(name, path = None):
        if name != "dsh":
            return None
        return os.path.join(system_dir if path is None else path, "dsh")

    with (
        patch("utils.coding_agents.shutil.which", side_effect = which),
        patch(
            "utils.coding_agents.is_deepseek_harness_executable",
            side_effect = lambda executable, **_: os.path.dirname(executable) == harness_dir,
        ),
    ):
        assert detect_installed_coding_agents() == ["dsh"]


def test_detects_dsh_that_identifies_as_deepseek_harness():
    with (
        patch(
            "utils.coding_agents.shutil.which",
            side_effect = lambda name: "/usr/local/bin/dsh" if name == "dsh" else None,
        ),
        patch("utils.coding_agents.is_deepseek_harness_executable", return_value = True),
    ):
        assert detect_installed_coding_agents() == ["dsh"]


def test_identifies_an_npm_dsh_launcher_without_executing_it(tmp_path):
    launcher = tmp_path / "dsh"
    launcher.write_text(
        '#!/bin/sh\nexec node /usr/lib/node_modules/@deepseek-ai/dsh/lib/bin.js "$@"\n'
    )
    with patch(
        "utils.coding_agents.subprocess.run",
        side_effect = AssertionError("advisory detection must not execute the launcher"),
    ):
        assert is_deepseek_harness_executable(str(launcher), allow_execution = False)


# Verbatim npm cmd-shim output for `npm install -g @deepseek-ai/dsh` on Windows.
_NPM_DSH_CMD_SHIM = (
    "@ECHO off\r\n"
    "GOTO start\r\n"
    ":find_dp0\r\n"
    "SET dp0=%~dp0\r\n"
    "EXIT /b\r\n"
    ":start\r\n"
    "SETLOCAL\r\n"
    "CALL :find_dp0\r\n"
    "\r\n"
    'IF EXIST "%dp0%\\node.exe" (\r\n'
    '  SET "_prog=%dp0%\\node.exe"\r\n'
    ") ELSE (\r\n"
    '  SET "_prog=node"\r\n'
    ")\r\n"
    "\r\n"
    "endLocal & goto #_undefined_# 2>NUL || title %COMSPEC% & set PATHEXT=%PATHEXT:;.JS;=;% & "
    '"%_prog%"  "%dp0%\\node_modules\\@deepseek-ai\\dsh\\lib\\bin.js" %*\r\n'
)


def test_identifies_a_windows_npm_dsh_cmd_shim_without_executing_it(tmp_path):
    launcher = tmp_path / "dsh.cmd"
    launcher.write_text(_NPM_DSH_CMD_SHIM, newline = "")
    with patch(
        "utils.coding_agents.subprocess.run",
        side_effect = AssertionError("advisory detection must not execute the launcher"),
    ):
        assert is_deepseek_harness_executable(str(launcher), allow_execution = False)


@pytest.mark.skipif(sys.platform != "win32", reason = "PATHEXT resolution of an npm .cmd shim")
def test_detects_windows_npm_dsh_cmd_shim_on_path(tmp_path, monkeypatch):
    (tmp_path / "dsh.cmd").write_text(_NPM_DSH_CMD_SHIM, newline = "")
    monkeypatch.setenv("PATH", str(tmp_path))
    with patch(
        "utils.coding_agents.subprocess.run",
        side_effect = AssertionError("advisory detection must not execute the launcher"),
    ):
        assert "dsh" in detect_installed_coding_agents()


def test_explicit_launch_can_probe_a_custom_dsh_wrapper(tmp_path):
    launcher = tmp_path / "dsh"
    launcher.write_text("#!/bin/sh\n")
    with patch(
        "utils.coding_agents.subprocess.run",
        return_value = CompletedProcess(
            [str(launcher), "--help"],
            0,
            stdout = "dsh: boot a DeepSeek Harness profile\n",
            stderr = "",
        ),
    ):
        assert is_deepseek_harness_executable(str(launcher))


def test_explicit_probe_replaces_undecodable_help_bytes(tmp_path):
    launcher = tmp_path / "dsh"
    launcher.write_text("#!/bin/sh\n")

    def probe(command, **kwargs):
        assert kwargs["encoding"] == "utf-8"
        assert kwargs["errors"] == "replace"
        return CompletedProcess(
            command,
            0,
            stdout = "\ufffd dsh: boot a DeepSeek Harness profile\n",
            stderr = "",
        )

    with patch("utils.coding_agents.subprocess.run", side_effect = probe):
        assert is_deepseek_harness_executable(str(launcher))