Skip to content

"CLI-Anything: Making ALL Software Agent-Native" -- CLI-Hub: https://clianything.cc/

Python

feat: add ComfyUI agent harness

Andrew Barnesd40750e3d4f8
diff --git a/comfyui/agent-harness/cli_anything/comfyui/tests/test_core.py b/comfyui/agent-harness/cli_anything/comfyui/tests/test_core.py
new file mode 100644
index 000000000..3f55565c9
--- /dev/null
+++ b/comfyui/agent-harness/cli_anything/comfyui/tests/test_core.py
@@ -0,0 +1,789 @@
+"""Unit tests for ComfyUI CLI harness — no ComfyUI installation required.
+
+Tests cover:
+- Workflow load/save/list/validate
+- Queue operations (prompt, status, clear, history, interrupt)
+- Model listing (checkpoints, LoRAs, VAEs, ControlNets, node info)
+- Image listing and downloading
+- CLI command parsing and output
+- Error handling and edge cases
+
+Run with:
+ python -m pytest comfyui/tests/test_core.py
+ python -m pytest comfyui/tests/test_core.py -v
+"""
+
+import json
+from pathlib import Path
+from unittest.mock import patch, MagicMock
+import pytest
+from click.testing import CliRunner
+
+from cli_anything.comfyui.comfyui_cli import cli
+from cli_anything.comfyui.core import workflows as workflow_mod
+from cli_anything.comfyui.core import queue as queue_mod
+from cli_anything.comfyui.core import models as models_mod
+from cli_anything.comfyui.core import images as images_mod
+
+
+# ── Fixtures ────────────────────────────────────────────────────
+
+def runner():
+ """Click CLI test runner."""
+ return CliRunner()
+
+
+def sample_workflow():
+ """Minimal valid ComfyUI workflow (API format)."""
+ return {
+ "4": {
+ "class_type": "CheckpointLoaderSimple",
+ "inputs": {"ckpt_name": "v1-5-pruned-emaonly.ckpt"}
+ },
+ "6": {
+ "class_type": "CLIPTextEncode",
+ "inputs": {"text": "a photo of a cat", "clip": ["4", 1]}
+ },
+ "7": {
+ "class_type": "CLIPTextEncode",
+ "inputs": {"text": "bad quality", "clip": ["4", 1]}
+ },
+ "5": {
+ "class_type": "EmptyLatentImage",
+ "inputs": {"batch_size": 1, "height": 512, "width": 512}
+ },
+ "3": {
+ "class_type": "KSampler",
+ "inputs": {
+ "cfg": 7, "denoise": 1, "model": ["4", 0],
+ "negative": ["7", 0], "positive": ["6", 0],
+ "latent_image": ["5", 0], "sampler_name": "euler",
+ "scheduler": "normal", "seed": 42, "steps": 20
+ }
+ },
+ "8": {
+ "class_type": "VAEDecode",
+ "inputs": {"samples": ["3", 0], "vae": ["4", 2]}
+ },
+ "9": {
+ "class_type": "SaveImage",
+ "inputs": {"filename_prefix": "ComfyUI", "images": ["8", 0]}
+ }
+ }
+
+
+def workflow_file(tmp_path, sample_workflow):
+ """Write sample workflow to a temp file and return the path."""
+ p = tmp_path / "test_workflow.json"
+ p.write_text(json.dumps(sample_workflow))
+ return str(p)
+
+
+# ── Workflow Tests ───────────────────────────────────────────────
+
+class TestWorkflowLoad:
+ """Test workflow file loading."""
+
+ def test_load_valid_workflow(self, workflow_file, sample_workflow):
+ """Should load a valid workflow JSON file."""
+ result = workflow_mod.load_workflow(workflow_file)
+ assert result == sample_workflow
+ assert "3" in result
+
+ def test_load_nonexistent_file(self):
+ """Should raise RuntimeError for missing file."""
+ with pytest.raises(RuntimeError, match="not found"):
+ workflow_mod.load_workflow("/nonexistent/path/workflow.json")
+
+ def test_load_non_json_extension(self, tmp_path):
+ """Should raise RuntimeError for non-.json file."""
+ p = tmp_path / "workflow.txt"
+ p.write_text("{}")
+ with pytest.raises(RuntimeError, match=".json"):
+ workflow_mod.load_workflow(str(p))
+
+ def test_load_invalid_json(self, tmp_path):
+ """Should raise RuntimeError for malformed JSON."""
+ p = tmp_path / "bad.json"
+ p.write_text("{not valid json")
+ with pytest.raises(RuntimeError, match="Invalid JSON"):
+ workflow_mod.load_workflow(str(p))
+
+ def test_load_non_dict_json(self, tmp_path):
+ """Should raise RuntimeError if JSON root is not a dict."""
+ p = tmp_path / "list.json"
+ p.write_text("[1, 2, 3]")
+ with pytest.raises(RuntimeError, match="JSON object"):
+ workflow_mod.load_workflow(str(p))
+
+
+class TestWorkflowSave:
+ """Test workflow file saving."""
+
+ def test_save_workflow(self, tmp_path, sample_workflow):
+ """Should save workflow to JSON file."""
+ dest = str(tmp_path / "saved.json")
+ result = workflow_mod.save_workflow(sample_workflow, dest)
+ assert result["status"] == "saved"
+ assert result["node_count"] == len(sample_workflow)
+ assert Path(dest).exists()
+ loaded = json.loads(Path(dest).read_text())
+ assert loaded == sample_workflow
+
+ def test_save_creates_parent_dirs(self, tmp_path, sample_workflow):
+ """Should create parent directories if they don't exist."""
+ dest = str(tmp_path / "nested" / "deep" / "workflow.json")
+ result = workflow_mod.save_workflow(sample_workflow, dest)
+ assert result["status"] == "saved"
+ assert Path(dest).exists()
+
+ def test_save_non_dict_raises(self):
+ """Should raise RuntimeError if workflow is not a dict."""
+ with pytest.raises(RuntimeError, match="must be a dict"):
+ workflow_mod.save_workflow([1, 2, 3], "/tmp/test.json")
+
+
+class TestWorkflowList:
+ """Test listing workflow files in a directory."""
+
+ def test_list_workflows(self, tmp_path, sample_workflow):
+ """Should list all JSON files in directory."""
+ (tmp_path / "workflow1.json").write_text(json.dumps(sample_workflow))
+ (tmp_path / "workflow2.json").write_text(json.dumps({"1": {"class_type": "SaveImage", "inputs": {}}}))
+ (tmp_path / "not_json.txt").write_text("ignored")
+
+ result = workflow_mod.list_workflows(str(tmp_path))
+ assert len(result) == 2
+ filenames = [r["filename"] for r in result]
+ assert "workflow1.json" in filenames
+ assert "workflow2.json" in filenames
+
+ def test_list_empty_directory(self, tmp_path):
+ """Should return empty list for directory with no JSON files."""
+ result = workflow_mod.list_workflows(str(tmp_path))
+ assert result == []
+
+ def test_list_nonexistent_directory(self):
+ """Should raise RuntimeError for nonexistent directory."""
+ with pytest.raises(RuntimeError, match="not found"):
+ workflow_mod.list_workflows("/nonexistent/dir/xyz")
+
+
+class TestWorkflowValidate:
+ """Test workflow validation."""
+
+ def test_valid_workflow(self, sample_workflow):
+ """Should pass validation for a well-formed workflow."""
+ result = workflow_mod.validate_workflow(sample_workflow)
+ assert result["valid"] is True
+ assert result["node_count"] == len(sample_workflow)
+ assert result["errors"] == []
+
+ def test_empty_workflow(self):
+ """Should warn about empty workflow but not fail."""
+ result = workflow_mod.validate_workflow({})
+ assert result["valid"] is True
+ assert any("empty" in w.lower() for w in result["warnings"])
+
+ def test_missing_class_type(self):
+ """Should error on node missing class_type."""
+ wf = {"1": {"inputs": {"text": "hello"}}}
+ result = workflow_mod.validate_workflow(wf)
+ assert result["valid"] is False
+ assert any("class_type" in e for e in result["errors"])
+
+ def test_non_dict_inputs(self):
+ """Should error when inputs is not a dict."""
+ wf = {"1": {"class_type": "CLIPTextEncode", "inputs": ["bad"]}}
+ result = workflow_mod.validate_workflow(wf)
+ assert result["valid"] is False
+
+ def test_non_dict_workflow(self):
+ """Should fail validation if workflow is not a dict."""
+ result = workflow_mod.validate_workflow("not a dict")
+ assert result["valid"] is False
+ assert result["node_count"] == 0
+
+
+# ── Queue Tests ──────────────────────────────────────────────────
+
+class TestQueuePrompt:
+ """Test submitting prompts to the queue."""
+
+ def test_queue_prompt_success(self, sample_workflow):
+ """Should return prompt_id and queue position."""
+ mock_response = {
+ "prompt_id": "abc-123-def",
+ "number": 0,
+ "node_errors": {},
+ }
+ with patch("cli_anything.comfyui.core.queue.api_post", return_value=mock_response):
+ result = queue_mod.queue_prompt("http://localhost:8188", sample_workflow)
+
+ assert result["prompt_id"] == "abc-123-def"
+ assert result["number"] == 0
+ assert result["node_errors"] == {}
+ assert "client_id" in result
+
+ def test_queue_prompt_with_client_id(self, sample_workflow):
+ """Should use provided client_id."""
+ mock_response = {"prompt_id": "xyz", "number": 1, "node_errors": {}}
+ with patch("cli_anything.comfyui.core.queue.api_post", return_value=mock_response) as mock_post:
+ result = queue_mod.queue_prompt("http://localhost:8188", sample_workflow, client_id="my-client")
+
+ assert result["client_id"] == "my-client"
+ call_args = mock_post.call_args
+ assert call_args[0][2]["client_id"] == "my-client"
+
+ def test_queue_empty_workflow_raises(self):
+ """Should raise RuntimeError for empty workflow."""
+ with pytest.raises(RuntimeError, match="empty"):
+ queue_mod.queue_prompt("http://localhost:8188", {})
+
+ def test_queue_prompt_server_error_raises(self, sample_workflow):
+ """Should raise RuntimeError when server returns error."""
+ mock_response = {
+ "error": {"message": "Invalid prompt", "type": "value_error"}
+ }
+ with patch("cli_anything.comfyui.core.queue.api_post", return_value=mock_response):
+ with pytest.raises(RuntimeError, match="rejected"):
+ queue_mod.queue_prompt("http://localhost:8188", sample_workflow)
+
+
+class TestQueueStatus:
+ """Test queue status retrieval."""
+
+ def test_get_queue_status(self):
+ """Should return running and pending counts."""
+ mock_response = {
+ "queue_running": [["abc", {}, {}, {}]],
+ "queue_pending": [["def", {}, {}, {}], ["ghi", {}, {}, {}]],
+ }
+ with patch("cli_anything.comfyui.core.queue.api_get", return_value=mock_response):
+ result = queue_mod.get_queue_status("http://localhost:8188")
+
+ assert result["running_count"] == 1
+ assert result["pending_count"] == 2
+
+ def test_get_queue_status_empty(self):
+ """Should handle empty queue."""
+ mock_response = {"queue_running": [], "queue_pending": []}
+ with patch("cli_anything.comfyui.core.queue.api_get", return_value=mock_response):
+ result = queue_mod.get_queue_status("http://localhost:8188")
+
+ assert result["running_count"] == 0
+ assert result["pending_count"] == 0
+
+
+class TestQueueClear:
+ """Test queue clearing."""
+
+ def test_clear_queue(self):
+ """Should return cleared status."""
+ with patch("cli_anything.comfyui.core.queue.api_delete", return_value={"status": "ok"}):
+ result = queue_mod.clear_queue("http://localhost:8188")
+
+ assert result["status"] == "cleared"
+
+ def test_clear_queue_passes_clear_flag(self):
+ """Should pass clear=True to the API."""
+ with patch("cli_anything.comfyui.core.queue.api_delete", return_value={}) as mock_del:
+ queue_mod.clear_queue("http://localhost:8188")
+
+ call_args = mock_del.call_args
+ # data kwarg or positional arg should contain {"clear": True}
+ data_arg = call_args[1].get("data") or (call_args[0][2] if len(call_args[0]) > 2 else None)
+ assert data_arg == {"clear": True}
+
+
+class TestQueueHistory:
+ """Test prompt history retrieval."""
+
+ def test_get_history(self):
+ """Should format history entries with outputs."""
+ mock_response = {
+ "abc-123": {
+ "outputs": {
+ "9": {
+ "images": [
+ {"filename": "ComfyUI_00001_.png", "subfolder": "", "type": "output"}
+ ]
+ }
+ },
+ "status": {"status_str": "success", "completed": True}
+ }
+ }
+ with patch("cli_anything.comfyui.core.queue.api_get", return_value=mock_response):
+ result = queue_mod.get_history("http://localhost:8188")
+
+ assert result["total"] == 1
+ assert "abc-123" in result["history"]
+ entry = result["history"]["abc-123"]
+ assert entry["completed"] is True
+ assert len(entry["outputs"]) == 1
+ assert entry["outputs"][0]["filename"] == "ComfyUI_00001_.png"
+
+ def test_get_prompt_history_not_found(self):
+ """Should raise RuntimeError when prompt ID not in history."""
+ with patch("cli_anything.comfyui.core.queue.api_get", return_value={}):
+ with pytest.raises(RuntimeError, match="not found"):
+ queue_mod.get_prompt_history("http://localhost:8188", "nonexistent-id")
+
+ def test_interrupt(self):
+ """Should call interrupt endpoint and return status."""
+ with patch("cli_anything.comfyui.core.queue.api_post", return_value={}):
+ result = queue_mod.interrupt("http://localhost:8188")
+ assert result["status"] == "interrupted"
+
+
+# ── Models Tests ─────────────────────────────────────────────────
+
+class TestModels:
+ """Test model listing functions."""
+
+ def _make_checkpoint_response(self, names):
+ return {"CheckpointLoaderSimple": {"input": {"required": {"ckpt_name": [names, {}]}}}}
+
+ def _make_lora_response(self, names):
+ return {"LoraLoader": {"input": {"required": {"lora_name": [names, {}]}}}}
+
+ def _make_vae_response(self, names):
+ return {"VAELoader": {"input": {"required": {"vae_name": [names, {}]}}}}
+
+ def _make_controlnet_response(self, names):
+ return {"ControlNetLoader": {"input": {"required": {"control_net_name": [names, {}]}}}}
+
+ def test_list_checkpoints(self):
+ """Should return sorted list of checkpoint names."""
+ mock_resp = self._make_checkpoint_response([
+ "sd_xl_base_1.0.safetensors", "v1-5-pruned-emaonly.ckpt", "deliberate_v2.safetensors",
+ ])
+ with patch("cli_anything.comfyui.core.models.api_get", return_value=mock_resp):
+ result = models_mod.list_checkpoints("http://localhost:8188")
+
+ assert isinstance(result, list)
+ assert len(result) == 3
+ assert result == sorted(result)
+
+ def test_list_loras(self):
+ """Should return sorted list of LoRA names."""
+ mock_resp = self._make_lora_response(["lora_b.safetensors", "lora_a.safetensors"])
+ with patch("cli_anything.comfyui.core.models.api_get", return_value=mock_resp):
+ result = models_mod.list_loras("http://localhost:8188")
+
+ assert result == ["lora_a.safetensors", "lora_b.safetensors"]
+
+ def test_list_vaes(self):
+ """Should return sorted list of VAE names."""
+ mock_resp = self._make_vae_response(["vae-ft-mse-840000-ema-pruned.ckpt"])
+ with patch("cli_anything.comfyui.core.models.api_get", return_value=mock_resp):
+ result = models_mod.list_vaes("http://localhost:8188")
+
+ assert "vae-ft-mse-840000-ema-pruned.ckpt" in result
+
+ def test_list_controlnets(self):
+ """Should return sorted list of ControlNet names."""
+ mock_resp = self._make_controlnet_response(["control_v11p_sd15_canny.pth"])
+ with patch("cli_anything.comfyui.core.models.api_get", return_value=mock_resp):
+ result = models_mod.list_controlnets("http://localhost:8188")
+
+ assert "control_v11p_sd15_canny.pth" in result
+
+ def test_list_checkpoints_bad_response_raises(self):
+ """Should raise RuntimeError on unexpected API response."""
+ with patch("cli_anything.comfyui.core.models.api_get", return_value={}):
+ with pytest.raises(RuntimeError, match="checkpoint"):
+ models_mod.list_checkpoints("http://localhost:8188")
+
+ def test_get_node_info(self):
+ """Should return formatted node schema."""
+ mock_resp = {
+ "KSampler": {
+ "display_name": "KSampler",
+ "description": "Samples latents",
+ "category": "sampling",
+ "input": {"required": {"steps": [["INT"], {"default": 20}]}},
+ "output": ["LATENT"],
+ "output_name": ["LATENT"],
+ }
+ }
+ with patch("cli_anything.comfyui.core.models.api_get", return_value=mock_resp):
+ result = models_mod.get_node_info("http://localhost:8188", "KSampler")
+
+ assert result["class_type"] == "KSampler"
+ assert result["category"] == "sampling"
+
+ def test_get_node_info_not_found_raises(self):
+ """Should raise RuntimeError when node class not in response."""
+ with patch("cli_anything.comfyui.core.models.api_get", return_value={}):
+ with pytest.raises(RuntimeError, match="not found"):
+ models_mod.get_node_info("http://localhost:8188", "NonExistentNode")
+
+ def test_list_all_node_classes(self):
+ """Should return sorted list of all node class names."""
+ mock_resp = {"KSampler": {}, "CLIPTextEncode": {}, "SaveImage": {}}
+ with patch("cli_anything.comfyui.core.models.api_get", return_value=mock_resp):
+ result = models_mod.list_all_node_classes("http://localhost:8188")
+
+ assert result == ["CLIPTextEncode", "KSampler", "SaveImage"]
+
+
+# ── Images Tests ─────────────────────────────────────────────────
+
+class TestImages:
+ """Test image listing and downloading."""
+
+ def test_list_output_images(self):
+ """Should return list of image file refs for a prompt."""
+ mock_history = {
+ "prompt_id": "abc-123",
+ "status": "success",
+ "completed": True,
+ "outputs": [
+ {"node_id": "9", "filename": "ComfyUI_00001_.png",
+ "subfolder": "", "type": "output"}
+ ]
+ }
+ with patch("cli_anything.comfyui.core.images.get_prompt_history",
+ return_value=mock_history):
+ result = images_mod.list_output_images("http://localhost:8188", "abc-123")
+
+ assert len(result) == 1
+ assert result[0]["filename"] == "ComfyUI_00001_.png"
+
+ def test_list_output_images_incomplete_raises(self):
+ """Should raise RuntimeError when prompt not yet complete."""
+ mock_history = {
+ "prompt_id": "abc-123",
+ "status": "running",
+ "completed": False,
+ "outputs": []
+ }
+ with patch("cli_anything.comfyui.core.images.get_prompt_history",
+ return_value=mock_history):
+ with pytest.raises(RuntimeError, match="not completed"):
+ images_mod.list_output_images("http://localhost:8188", "abc-123")
+
+ def test_download_image(self, tmp_path):
+ """Should download image bytes and write to disk."""
+ fake_png = b"\x89PNG\r\n\x1a\n" + b"\x00" * 100
+ dest = str(tmp_path / "output.png")
+
+ with patch("cli_anything.comfyui.core.images.api_get_raw", return_value=fake_png):
+ result = images_mod.download_image(
+ base_url="http://localhost:8188",
+ filename="ComfyUI_00001_.png",
+ output_path=dest,
+ )
+
+ assert result["status"] == "downloaded"
+ assert result["size_bytes"] == len(fake_png)
+ assert Path(dest).read_bytes() == fake_png
+
+ def test_download_image_no_overwrite_raises(self, tmp_path):
+ """Should raise RuntimeError when output file exists and overwrite=False."""
+ dest = tmp_path / "existing.png"
+ dest.write_bytes(b"existing content")
+
+ with pytest.raises(RuntimeError, match="already exists"):
+ images_mod.download_image(
+ base_url="http://localhost:8188",
+ filename="ComfyUI_00001_.png",
+ output_path=str(dest),
+ overwrite=False,
+ )
+
+ def test_download_image_overwrite(self, tmp_path):
+ """Should overwrite existing file when overwrite=True."""
+ dest = tmp_path / "existing.png"
+ dest.write_bytes(b"old content")
+ fake_png = b"\x89PNG\r\n\x1a\n" + b"\x00" * 50
+
+ with patch("cli_anything.comfyui.core.images.api_get_raw", return_value=fake_png):
+ images_mod.download_image(
+ base_url="http://localhost:8188",
+ filename="ComfyUI_00001_.png",
+ output_path=str(dest),
+ overwrite=True,
+ )
+
+ assert dest.read_bytes() == fake_png
+
+ def test_download_prompt_images(self, tmp_path):
+ """Should download all images for a prompt to a directory."""
+ mock_history = {
+ "prompt_id": "abc-123",
+ "status": "success",
+ "completed": True,
+ "outputs": [
+ {"node_id": "9", "filename": "ComfyUI_00001_.png", "subfolder": "", "type": "output"},
+ {"node_id": "9", "filename": "ComfyUI_00002_.png", "subfolder": "", "type": "output"},
+ ]
+ }
+ fake_png = b"\x89PNG\r\n\x1a\n" + b"\x00" * 20
+
+ with patch("cli_anything.comfyui.core.images.get_prompt_history", return_value=mock_history), \
+ patch("cli_anything.comfyui.core.images.api_get_raw", return_value=fake_png):
+ results = images_mod.download_prompt_images(
+ base_url="http://localhost:8188",
+ prompt_id="abc-123",
+ output_dir=str(tmp_path),
+ )
+
+ assert len(results) == 2
+ assert all(r["status"] == "downloaded" for r in results)
+
+
+# ── CLI Integration Tests ─────────────────────────────────────────
+
+class TestCLIWorkflow:
+ """Test CLI workflow commands."""
+
+ def test_workflow_list(self, runner, tmp_path, sample_workflow):
+ """workflow list should display JSON files."""
+ (tmp_path / "my_wf.json").write_text(json.dumps(sample_workflow))
+
+ result = runner.invoke(cli, ["workflow", "list", str(tmp_path)])
+ assert result.exit_code == 0
+ assert "my_wf.json" in result.output
+
+ def test_workflow_validate_valid(self, runner, workflow_file):
+ """workflow validate should pass for a valid workflow."""
+ result = runner.invoke(cli, ["workflow", "validate", workflow_file])
+ assert result.exit_code == 0
+ assert "valid" in result.output.lower()
+
+ def test_workflow_validate_json_output(self, runner, workflow_file):
+ """--json flag should produce valid JSON output."""
+ result = runner.invoke(cli, ["--json", "workflow", "validate", workflow_file])
+ assert result.exit_code == 0
+ data = json.loads(result.output)
+ assert "valid" in data
+ assert "node_count" in data
+
+
+class TestCLIQueue:
+ """Test CLI queue commands."""
+
+ def test_queue_prompt(self, runner, workflow_file):
+ """queue prompt should queue a workflow and show prompt_id."""
+ mock_response = {"prompt_id": "test-id-999", "number": 0, "node_errors": {}}
+ with patch("cli_anything.comfyui.core.queue.api_post", return_value=mock_response):
+ result = runner.invoke(cli, ["queue", "prompt", "--workflow", workflow_file])
+
+ assert result.exit_code == 0
+ assert "test-id-999" in result.output
+
+ def test_queue_status(self, runner):
+ """queue status should show running and pending counts."""
+ mock_response = {"queue_running": [], "queue_pending": [["id1", {}, {}, {}]]}
+ with patch("cli_anything.comfyui.core.queue.api_get", return_value=mock_response):
+ result = runner.invoke(cli, ["queue", "status"])
+
+ assert result.exit_code == 0
+ assert "1" in result.output
+
+ def test_queue_clear_with_confirm(self, runner):
+ """queue clear --confirm should skip prompt and clear."""
+ with patch("cli_anything.comfyui.core.queue.api_delete", return_value={}):
+ result = runner.invoke(cli, ["queue", "clear", "--confirm"])
+
+ assert result.exit_code == 0
+ assert "cleared" in result.output
+
+ def test_queue_history_json(self, runner):
+ """queue history --json should return valid JSON."""
+ mock_response = {
+ "abc": {"outputs": {}, "status": {"status_str": "success", "completed": True}}
+ }
+ with patch("cli_anything.comfyui.core.queue.api_get", return_value=mock_response):
+ result = runner.invoke(cli, ["--json", "queue", "history"])
+
+ assert result.exit_code == 0
+ data = json.loads(result.output)
+ assert "history" in data
+ assert "total" in data
+
+
+class TestCLIModels:
+ """Test CLI models commands."""
+
+ def test_models_checkpoints(self, runner):
+ """models checkpoints should list checkpoint names."""
+ mock_resp = {
+ "CheckpointLoaderSimple": {
+ "input": {"required": {"ckpt_name": [["v1-5-pruned-emaonly.ckpt", "sd_xl_base_1.0.safetensors"], {}]}}
+ }
+ }
+ with patch("cli_anything.comfyui.core.models.api_get", return_value=mock_resp):
+ result = runner.invoke(cli, ["models", "checkpoints"])
+
+ assert result.exit_code == 0
+ assert "v1-5-pruned-emaonly.ckpt" in result.output
+
+ def test_models_checkpoints_json(self, runner):
+ """models checkpoints --json should return a JSON array."""
+ mock_resp = {
+ "CheckpointLoaderSimple": {
+ "input": {"required": {"ckpt_name": [["model_a.safetensors"], {}]}}
+ }
+ }
+ with patch("cli_anything.comfyui.core.models.api_get", return_value=mock_resp):
+ result = runner.invoke(cli, ["--json", "models", "checkpoints"])
+
+ assert result.exit_code == 0
+ data = json.loads(result.output)
+ assert isinstance(data, list)
+ assert "model_a.safetensors" in data
+
+
+class TestCLIImages:
+ """Test CLI images commands."""
+
+ def test_images_list(self, runner):
+ """images list should show output filenames."""
+ mock_history = {
+ "prompt_id": "abc-123",
+ "status": "success",
+ "completed": True,
+ "outputs": [{"node_id": "9", "filename": "ComfyUI_00001_.png", "subfolder": "", "type": "output"}]
+ }
+ with patch("cli_anything.comfyui.core.images.get_prompt_history", return_value=mock_history):
+ result = runner.invoke(cli, ["images", "list", "--prompt-id", "abc-123"])
+
+ assert result.exit_code == 0
+ assert "ComfyUI_00001_.png" in result.output
+
+ def test_images_download(self, runner, tmp_path):
+ """images download should save file to disk."""
+ fake_png = b"\x89PNG\r\n\x1a\n" + b"\x00" * 30
+ dest = str(tmp_path / "out.png")
+
+ with patch("cli_anything.comfyui.core.images.api_get_raw", return_value=fake_png):
+ result = runner.invoke(cli, [
+ "images", "download",
+ "--filename", "ComfyUI_00001_.png",
+ "--output", dest,
+ ])
+
+ assert result.exit_code == 0
+ assert "downloaded" in result.output.lower()
+ assert Path(dest).exists()
+
+
+class TestCLISystem:
+ """Test CLI system commands."""
+
+ def test_system_stats(self, runner):
+ """system stats should display server info."""
+ mock_stats = {
+ "system": {"os": "linux", "python_version": "3.11"},
+ "devices": [{"name": "NVIDIA RTX 3060", "vram_total": 12884901888}]
+ }
+ with patch("cli_anything.comfyui.comfyui_cli.api_get", return_value=mock_stats):
+ result = runner.invoke(cli, ["system", "stats"])
+
+ assert result.exit_code == 0
+
+ def test_system_stats_json(self, runner):
+ """system stats --json should return valid JSON."""
+ mock_stats = {"system": {"os": "linux"}, "devices": []}
+ with patch("cli_anything.comfyui.comfyui_cli.api_get", return_value=mock_stats):
+ result = runner.invoke(cli, ["--json", "system", "stats"])
+
+ assert result.exit_code == 0
+ data = json.loads(result.output)
+ assert "system" in data
+
+
+# ── Backend Tests ────────────────────────────────────────────────
+
+class TestBackend:
+ """Test comfyui_backend HTTP wrappers."""
+
+ def test_api_get_success(self):
+ """api_get should return parsed JSON on success."""
+ from cli_anything.comfyui.utils.comfyui_backend import api_get
+
+ mock_resp = MagicMock()
+ mock_resp.status_code = 200
+ mock_resp.content = b'{"result": "ok"}'
+ mock_resp.json.return_value = {"result": "ok"}
+ mock_resp.raise_for_status = MagicMock()
+
+ with patch("cli_anything.comfyui.utils.comfyui_backend.requests.get",
+ return_value=mock_resp):
+ result = api_get("http://localhost:8188", "/queue")
+
+ assert result == {"result": "ok"}
+
+ def test_api_get_connection_error(self):
+ """api_get should raise RuntimeError on connection failure."""
+ import requests as req
+ from cli_anything.comfyui.utils.comfyui_backend import api_get
+
+ with patch("cli_anything.comfyui.utils.comfyui_backend.requests.get",
+ side_effect=req.exceptions.ConnectionError("refused")):
+ with pytest.raises(RuntimeError, match="Cannot connect"):
+ api_get("http://localhost:8188", "/queue")
+
+ def test_api_post_success(self):
+ """api_post should return parsed JSON on success."""
+ from cli_anything.comfyui.utils.comfyui_backend import api_post
+
+ mock_resp = MagicMock()
+ mock_resp.status_code = 200
+ mock_resp.content = b'{"prompt_id": "abc"}'
+ mock_resp.json.return_value = {"prompt_id": "abc"}
+ mock_resp.raise_for_status = MagicMock()
+
+ with patch("cli_anything.comfyui.utils.comfyui_backend.requests.post",
+ return_value=mock_resp):
+ result = api_post("http://localhost:8188", "/prompt", {"prompt": {}})
+
+ assert result["prompt_id"] == "abc"
+
+ def test_api_delete_success(self):
+ """api_delete should return ok status on 204."""
+ from cli_anything.comfyui.utils.comfyui_backend import api_delete
+
+ mock_resp = MagicMock()
+ mock_resp.status_code = 204
+ mock_resp.content = b""
+ mock_resp.raise_for_status = MagicMock()
+
+ with patch("cli_anything.comfyui.utils.comfyui_backend.requests.delete",
+ return_value=mock_resp):
+ result = api_delete("http://localhost:8188", "/queue")
+
+ assert result == {"status": "ok"}
+
+ def test_api_get_raw_returns_bytes(self):
+ """api_get_raw should return raw bytes."""
+ from cli_anything.comfyui.utils.comfyui_backend import api_get_raw
+
+ fake_bytes = b"\x89PNG\r\n\x1a\n" + b"\x00" * 50
+ mock_resp = MagicMock()
+ mock_resp.status_code = 200
+ mock_resp.content = fake_bytes
+ mock_resp.raise_for_status = MagicMock()
+
+ with patch("cli_anything.comfyui.utils.comfyui_backend.requests.get",
+ return_value=mock_resp):
+ result = api_get_raw("http://localhost:8188", "/view",
+ params={"filename": "ComfyUI_00001_.png", "type": "output"})
+
+ assert result == fake_bytes
+
+ def test_api_get_timeout_raises(self):
+ """api_get should raise RuntimeError on timeout."""
+ import requests as req
+ from cli_anything.comfyui.utils.comfyui_backend import api_get
+
+ with patch("cli_anything.comfyui.utils.comfyui_backend.requests.get",
+ side_effect=req.exceptions.Timeout()):
+ with pytest.raises(RuntimeError, match="timed out"):
+ api_get("http://localhost:8188", "/queue")