🚀 The fast, Pythonic way to build MCP servers and clients.
"""Tests for the fastmcp tasks CLI."""
from contextlib import asynccontextmanager
from types import SimpleNamespace
from unittest.mock import AsyncMock
import fastmcp_tasks.worker_cli as worker_cli
import pytest
from fastmcp_tasks.settings import DocketSettings
from fastmcp_tasks.worker_cli import (
check_distributed_backend,
redact_backend_url,
resolve_docket_settings,
tasks_app,
)
from rich.console import Console
from fastmcp import FastMCP
from fastmcp_tasks import TasksExtension
class TestResolveDocketSettings:
"""`resolve_docket_settings` reads the server's *registered* extension."""
def test_reads_the_registered_extensions_settings(self):
"""The constructor-configured URL is visible without any env var."""
mcp = FastMCP("t")
mcp.add_extension(TasksExtension(url="redis://example:6379/0"))
settings = resolve_docket_settings(mcp)
assert settings.url == "redis://example:6379/0"
def test_exits_when_no_tasks_extension_registered(self):
"""A server with no TasksExtension has nothing for the CLI to serve."""
mcp = FastMCP("t")
with pytest.raises(SystemExit) as exc_info:
resolve_docket_settings(mcp)
assert exc_info.value.code == 1
class TestCheckDistributedBackend:
"""Test the distributed backend checker function."""
def test_succeeds_with_redis_url(self):
"""Test that it succeeds with Redis URL."""
settings = DocketSettings(url="redis://localhost:6379/0")
check_distributed_backend(settings)
def test_exits_with_helpful_error_for_memory_url(self):
"""Test that it exits with helpful error for memory:// URLs."""
settings = DocketSettings(url="memory://test-123")
with pytest.raises(SystemExit) as exc_info:
check_distributed_backend(settings)
assert isinstance(exc_info.value, SystemExit)
assert exc_info.value.code == 1
class TestWorkerCommand:
"""Test the worker command."""
def test_worker_command_parsing(self):
"""Test that worker command parses arguments correctly."""
command, bound, _ = tasks_app.parse_args(["worker", "server.py"])
assert callable(command)
assert command.__name__ == "worker" # type: ignore[attr-defined] # ty:ignore[unresolved-attribute]
assert bound.arguments["server_spec"] == "server.py"
class TestRedactPassword:
"""The worker prints the backend URL without exposing its password."""
@pytest.mark.parametrize(
("url", "expected"),
[
(
"redis://default:S3cretPass@localhost:6390/0",
"redis://default:***@localhost:6390/0",
),
(
"redis://user:p@ss@localhost:6379/1",
"redis://user:***@localhost:6379/1",
),
(
"redis://:secret@localhost:6379/0",
"redis://:***@localhost:6379/0",
),
(
"redis://localhost:6379/0?password=secret",
"redis://localhost:6379/0?password=***",
),
(
"redis://localhost:6379/0?db=1&sentinel_password=secret",
"redis://localhost:6379/0?db=1&sentinel_password=***",
),
(
"redis://localhost:6379/0?Password=secret",
"redis://localhost:6379/0?Password=***",
),
],
)
def test_masks_the_password(self, url: str, expected: str):
assert redact_backend_url(url) == expected
@pytest.mark.parametrize(
("url", "expected"),
[
("redis://host?pass%77ord=secret", "redis://host?pass%77ord=***"),
(
"redis://host?sentinel_%70assword=secret&db=1",
"redis://host?sentinel_%70assword=***&db=1",
),
(
"rediss://u:p%40ss@[::1]:6379/0?password=one&password=two",
"rediss://u:***@[::1]:6379/0?password=***&password=***",
),
("redis://host?password=&timeout=5", "redis://host?password=***&timeout=5"),
("redis://host?password=a%26b%3Dc", "redis://host?password=***"),
(
"rediss://host?ssl_password=privatekeysecret",
"rediss://host?ssl_password=***",
),
(
"rediss://host?ssl_%70assword=privatekeysecret",
"rediss://host?ssl_%70assword=***",
),
(
"rediss+sentinel://host:26379/master?ssl_password=privatekeysecret",
"rediss+sentinel://host:26379/master?ssl_password=***",
),
(
"rediss+sentinel://host:26379/master?ssl_%70assword=privatekeysecret",
"rediss+sentinel://host:26379/master?ssl_%70assword=***",
),
("redis://u:secret@[invalid", "***"),
("redis://u:secret@host/name", "***"),
],
)
def test_encoded_and_malformed_credentials(self, url: str, expected: str):
assert redact_backend_url(url) == expected
@pytest.mark.parametrize(
"url",
[
"redis://localhost:6379/0",
"redis://user@localhost:6379/0",
"redis://localhost:6379/0?timeout=5",
"memory://",
],
)
def test_leaves_urls_without_a_password_alone(self, url: str):
assert redact_backend_url(url) == url
class TestTasksAppIntegration:
"""Test the tasks app integration."""
def test_tasks_app_exists(self):
"""Test that the tasks app is properly configured."""
assert "tasks" in tasks_app.name
assert "Docket" in tasks_app.help
def test_tasks_app_has_commands(self):
"""Test that all expected commands are registered."""
# Just verify the app exists and has the right metadata
# Detailed command testing is done in individual test classes
assert "tasks" in tasks_app.name
assert tasks_app.help
def test_worker_banner_redacts_credentials(monkeypatch, capsys):
settings = DocketSettings(url="redis://u:secret@host?pass%77ord=querysecret")
@asynccontextmanager
async def lifespan():
yield
server = SimpleNamespace(name="demo", _lifespan_manager=lifespan)
config = SimpleNamespace(
source=SimpleNamespace(load_server=AsyncMock(return_value=server))
)
monkeypatch.setattr(worker_cli, "load_and_merge_config", lambda _: (config, None))
monkeypatch.setattr(worker_cli, "resolve_docket_settings", lambda _: settings)
monkeypatch.setattr(worker_cli, "console", Console(width=200, color_system=None))
monkeypatch.setattr(
worker_cli.asyncio, "sleep", AsyncMock(side_effect=KeyboardInterrupt)
)
with pytest.raises(SystemExit) as exc:
worker_cli.worker("server.py")
assert exc.value.code == 0
output = capsys.readouterr().out
assert "Backend: redis://u:***@host?pass%77ord=***" in output
assert "secret" not in output
class TestRedactBackendUrl:
"""The worker prints the backend URL without its passwords."""
@pytest.mark.parametrize(
("url", "expected"),
[
(
"redis://tasks:[email protected]:6379/0",
"redis://tasks:***@redis.example.com:6379/0",
),
(
"rediss://:[email protected]/0",
"rediss://:***@redis.example.com/0",
),
(
"redis://redis.example.com/0?password=S3cret&socket_timeout=5",
"redis://redis.example.com/0?password=***&socket_timeout=5",
),
(
"redis+sentinel://u:S3cret@h1:26379,h2:26379/mymaster/0"
"?sentinel_password=S3cret2",
"redis+sentinel://u:***@h1:26379,h2:26379/mymaster/0"
"?sentinel_password=***",
),
],
)
def test_hides_passwords(self, url: str, expected: str):
assert redact_backend_url(url) == expected
@pytest.mark.parametrize(
"url",
[
"redis://localhost:6379/0",
"redis://tasks@localhost:6379/0",
"redis://localhost/0?ssl_ca_certs=/etc/ca.pem",
"memory://test-123",
],
)
def test_leaves_urls_without_passwords_unchanged(self, url: str):
assert redact_backend_url(url) == url