Personal AI, On Personal Devices
Python
"""Tests for the Python SDK — Jarvis class and MemoryHandle."""
from __future__ import annotations
from unittest.mock import MagicMock, patch
import pytest
import openjarvis
from openjarvis.core.config import JarvisConfig
from openjarvis.sdk import Jarvis, MemoryHandle
def _make_engine(content="Hello from SDK"):
engine = MagicMock()
engine.engine_id = "mock"
engine.health.return_value = True
engine.list_models.return_value = ["test-model"]
engine.generate.return_value = {
"content": content,
"usage": {"prompt_tokens": 5, "completion_tokens": 3, "total_tokens": 8},
"model": "test-model",
"finish_reason": "stop",
}
return engine
class TestJarvisInit:
def test_default_config(self):
j = Jarvis(config=JarvisConfig())
assert j.config is not None
j.close()
def test_custom_config(self):
cfg = JarvisConfig()
j = Jarvis(config=cfg)
assert j.config is cfg
j.close()
def test_version_property(self):
j = Jarvis(config=JarvisConfig())
assert j.version == openjarvis.__version__
j.close()
def test_engine_key_override(self):
j = Jarvis(config=JarvisConfig(), engine_key="custom")
assert j._engine_key == "custom"
j.close()
def test_model_override(self):
j = Jarvis(config=JarvisConfig(), model="my-model")
assert j._model_override == "my-model"
j.close()
class TestJarvisAsk:
def test_ask_returns_string(self):
engine = _make_engine("The answer is 42.")
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=JarvisConfig(), model="test-model")
result = j.ask("What is the answer?")
assert result == "The answer is 42."
j.close()
def test_ask_with_model_override(self):
engine = _make_engine()
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=JarvisConfig())
j.ask("Hello", model="custom-model")
# Verify engine.generate was called with the custom model
call_kwargs = engine.generate.call_args
assert call_kwargs[1]["model"] == "custom-model"
j.close()
def test_ask_with_agent(self):
from openjarvis.agents._stubs import AgentResult
from openjarvis.core.registry import AgentRegistry
engine = _make_engine()
class MockAgent:
agent_id = "mock-agent"
def __init__(self, eng, model, **kwargs):
pass
def run(self, input, context=None, **kwargs):
return AgentResult(content="Agent response", turns=1)
AgentRegistry.register_value("mock-agent", MockAgent)
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=JarvisConfig(), model="test-model")
result = j.ask("Hello", agent="mock-agent")
assert result == "Agent response"
j.close()
def test_simple_agent_ignores_tool_security_kwargs(self):
from openjarvis.agents.simple import SimpleAgent
from openjarvis.core.registry import AgentRegistry
from openjarvis.security import SecurityContext
engine = _make_engine("simple secured response")
AgentRegistry.register_value("simple", SimpleAgent)
with (
patch("openjarvis.sdk.get_engine", return_value=("mock", engine)),
patch(
"openjarvis.security.setup_security",
return_value=SecurityContext(
engine=engine,
capability_policy=object(),
rate_limiter=object(),
),
),
):
j = Jarvis(config=JarvisConfig(), model="test-model")
result = j.ask("Hello", agent="simple")
j.close()
assert result == "simple secured response"
def test_direct_operation_agent_receives_policy_rate_and_identity(self):
from openjarvis.agents._stubs import AgentContext, AgentResult, BaseAgent
from openjarvis.core.registry import AgentRegistry
from openjarvis.security import SecurityContext
from openjarvis.security.capabilities import CapabilityPolicy
class _RecordingLimiter:
def __init__(self):
self.keys = []
def check(self, key):
self.keys.append(key)
return True, 0.0
class _DirectSDKAgent(BaseAgent):
agent_id = "direct-sdk"
required_capabilities = ("code:execute",)
def run(self, input, context: AgentContext | None = None, **kwargs):
return self._execution_denied_result() or AgentResult(content="ran")
engine = _make_engine()
policy = CapabilityPolicy(default_deny=True)
policy.grant("_default", "code:execute")
policy.deny("direct-sdk", "code:execute")
limiter = _RecordingLimiter()
AgentRegistry.register_value("direct-sdk", _DirectSDKAgent)
with (
patch("openjarvis.sdk.get_engine", return_value=("mock", engine)),
patch(
"openjarvis.security.setup_security",
return_value=SecurityContext(
engine=engine,
capability_policy=policy,
rate_limiter=limiter,
),
),
):
j = Jarvis(config=JarvisConfig(), model="test-model")
result = j.ask("run", agent="direct-sdk")
j.close()
assert "code:execute" in result
assert limiter.keys == ["direct-sdk:agent_run"]
def test_ask_with_agent_wires_persona(self, tmp_path):
from openjarvis.agents.simple import SimpleAgent
from openjarvis.core.registry import AgentRegistry
soul = tmp_path / "SOUL.md"
soul.write_text("SDK_PERSONA_SENTINEL", encoding="utf-8")
cfg = JarvisConfig()
cfg.memory_files.soul_path = str(soul)
cfg.memory_files.memory_path = ""
cfg.memory_files.user_path = ""
cfg.agent.context_from_memory = False
if not AgentRegistry.contains("simple"):
AgentRegistry.register_value("simple", SimpleAgent)
engine = _make_engine()
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=cfg, model="test-model")
j.ask("Hello", agent="simple")
messages = engine.generate.call_args.args[0]
assert "SDK_PERSONA_SENTINEL" in messages[0].content
j.close()
def test_ask_no_engine_raises(self):
with patch("openjarvis.sdk.get_engine", return_value=None):
j = Jarvis(config=JarvisConfig())
with pytest.raises(RuntimeError, match="No inference engine"):
j.ask("Hello")
j.close()
def test_ask_full_returns_dict(self):
engine = _make_engine("Full response")
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=JarvisConfig(), model="test-model")
result = j.ask_full("Hello")
assert isinstance(result, dict)
assert "content" in result
assert "usage" in result
assert result["content"] == "Full response"
j.close()
class TestJarvisModels:
def test_list_models(self):
engine = _make_engine()
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=JarvisConfig())
models = j.list_models()
assert models == ["test-model"]
j.close()
def test_list_engines(self):
from openjarvis.core.registry import EngineRegistry
EngineRegistry.register_value("test-eng", object)
j = Jarvis(config=JarvisConfig())
engines = j.list_engines()
assert "test-eng" in engines
j.close()
def test_list_engines_empty(self):
j = Jarvis(config=JarvisConfig())
engines = j.list_engines()
assert isinstance(engines, list)
j.close()
class TestMemoryHandle:
def test_lazy_backend_init(self):
cfg = JarvisConfig()
handle = MemoryHandle(cfg)
assert handle._backend is None
handle.close()
def test_close_idempotent(self):
cfg = JarvisConfig()
handle = MemoryHandle(cfg)
handle.close()
handle.close() # should not raise
def test_index_file(self, tmp_path):
# Create a test file with enough content to produce chunks
test_file = tmp_path / "test.txt"
words = " ".join(f"word{i}" for i in range(100))
test_file.write_text(words)
# Mock the memory backend
mock_backend = MagicMock()
mock_backend.store.return_value = "doc-1"
cfg = JarvisConfig()
handle = MemoryHandle(cfg)
handle._backend = mock_backend
result = handle.index(str(test_file))
assert result["chunks"] > 0
assert "doc_ids" in result
handle.close()
def test_search_returns_results(self):
mock_backend = MagicMock()
mock_result = MagicMock()
mock_result.content = "test content"
mock_result.score = 0.9
mock_result.source = "test.txt"
mock_result.metadata = {}
mock_backend.retrieve.return_value = [mock_result]
cfg = JarvisConfig()
handle = MemoryHandle(cfg)
handle._backend = mock_backend
results = handle.search("test query")
assert len(results) == 1
assert results[0]["content"] == "test content"
handle.close()
def test_search_empty(self):
mock_backend = MagicMock()
mock_backend.retrieve.return_value = []
cfg = JarvisConfig()
handle = MemoryHandle(cfg)
handle._backend = mock_backend
results = handle.search("nothing")
assert results == []
handle.close()
def test_stats_returns_dict(self):
mock_backend = MagicMock()
mock_backend.count.return_value = 5
cfg = JarvisConfig()
handle = MemoryHandle(cfg)
handle._backend = mock_backend
stats = handle.stats()
assert isinstance(stats, dict)
assert stats["count"] == 5
handle.close()
class TestJarvisStreaming:
@pytest.mark.asyncio
async def test_ask_stream_yields_tokens(self):
engine = _make_engine()
async def mock_stream(*args, **kwargs):
for token in ["Hello", " ", "world"]:
yield token
engine.stream = mock_stream
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=JarvisConfig(), model="test-model")
tokens = []
async for token in j.ask_stream("Hi"):
tokens.append(token)
assert tokens == ["Hello", " ", "world"]
j.close()
@pytest.mark.asyncio
async def test_ask_full_stream_yields_dicts(self):
engine = _make_engine()
async def mock_stream(*args, **kwargs):
for token in ["Hello", " ", "world"]:
yield token
engine.stream = mock_stream
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=JarvisConfig(), model="test-model")
chunks = []
async for chunk in j.ask_full_stream("Hi"):
chunks.append(chunk)
# First three chunks are token dicts
assert chunks[0] == {"token": "Hello", "index": 0}
assert chunks[1] == {"token": " ", "index": 1}
assert chunks[2] == {"token": "world", "index": 2}
# Final chunk has done flag and full content
final = chunks[-1]
assert final["done"] is True
assert final["content"] == "Hello world"
assert final["model"] == "test-model"
assert final["engine"] == "mock"
j.close()
@pytest.mark.asyncio
async def test_ask_stream_with_model_override(self):
engine = _make_engine()
call_log: list = []
async def mock_stream(*args, **kwargs):
call_log.append(kwargs)
for token in ["ok"]:
yield token
engine.stream = mock_stream
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=JarvisConfig())
tokens = []
async for token in j.ask_stream("Hi", model="custom-model"):
tokens.append(token)
assert tokens == ["ok"]
assert call_log[0]["model"] == "custom-model"
j.close()
class TestJarvisLifecycle:
@pytest.mark.parametrize("security_enabled", [False, True])
def test_close_initialized_engine(self, security_enabled: bool) -> None:
from openjarvis.security.guardrails import GuardrailsEngine
cfg = JarvisConfig()
cfg.security.enabled = security_enabled
engine = _make_engine()
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=cfg)
try:
assert j.list_models() == ["test-model"]
assert (
isinstance(j._engine._inner, GuardrailsEngine) == security_enabled
)
j.close()
j.close()
engine.close.assert_called_once()
assert j._engine is None
finally:
j.close()
def test_context_manager_closes_initialized_engine(self) -> None:
engine = _make_engine()
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
with Jarvis(config=JarvisConfig()) as j:
j.list_models()
engine.close.assert_called_once()
def test_engine_close_failure_clears_reference(self) -> None:
engine = _make_engine()
engine.close.side_effect = RuntimeError("cleanup failed")
with patch("openjarvis.sdk.get_engine", return_value=("mock", engine)):
j = Jarvis(config=JarvisConfig())
try:
j.list_models()
j.close()
assert j._engine is None
j.close()
engine.close.assert_called_once()
finally:
j.close()
def test_close_releases_resources(self):
j = Jarvis(config=JarvisConfig())
j.close()
assert j._engine is None
def test_double_close_safe(self):
j = Jarvis(config=JarvisConfig())
j.close()
j.close() # should not raise