Publish tests/ from marimo

tests/test_api_surface.py

@@ -0,0 +1,38 @@
+"""The public API is a promise: everything advertised is importable, once."""
+
+import importlib
+import inspect
+
+import tiny_computer_agent as tca
+
+
+def test_everything_in_all_is_reachable_from_the_package_root():
+    missing = [name for name in tca.__all__ if not hasattr(tca, name)]
+    assert missing == [], f"advertised but not exported: {missing}"
+
+
+def test_all_is_sorted_and_free_of_duplicates():
+    assert tca.__all__ == sorted(tca.__all__), "keep __all__ alphabetical"
+    assert len(tca.__all__) == len(set(tca.__all__)), "no duplicate exports"
+
+
+def test_no_public_callable_in_a_module_is_missing_from_all():
+    """A capability a user cannot import is a capability they cannot use."""
+    modules = ["actions", "act", "observe", "perception", "brain", "models", "loop",
+               "safety", "desktop", "demo", "trace"]
+    unexported = []
+    for name in modules:
+        module = importlib.import_module(f"tiny_computer_agent.{name}")
+        for attr, obj in vars(module).items():
+            if attr.startswith("_") or getattr(obj, "__module__", "") != module.__name__:
+                continue
+            if attr in tca.__all__ or attr.endswith(("Error", "Unavailable", "Violation")):
+                continue
+            unexported.append(f"{name}.{attr}")
+    assert unexported == [], f"public names not exported from the package root: {unexported}"
+
+
+def test_the_documented_entry_points_are_callable():
+    for name in ["doctor", "run_checks", "display_available", "build_agent",
+                 "make_detector", "make_model_brain", "benchmark", "score"]:
+        assert callable(getattr(tca, name)), name

tests/test_models.py

@@ -0,0 +1,46 @@
+"""The model backends: laziness, device choice, and honest failures."""
+
+import pytest
+
+from tiny_computer_agent import (DEFAULT_TEXT_MODEL, DEFAULT_VISION_MODEL, MODEL_BRAINS,
+                                 BrainError, make_model_brain, model_cached, model_dependencies,
+                                 pick_dtype, resolve_device)
+
+
+def test_building_a_brain_does_not_load_any_weights():
+    """Constructing must be free: --doctor builds one on machines with no cache."""
+    for name in MODEL_BRAINS:
+        brain = make_model_brain(name)
+        assert brain.loaded is False
+        assert brain.model_id in (DEFAULT_TEXT_MODEL, DEFAULT_VISION_MODEL)
+
+
+def test_unload_returns_a_brain_to_the_unloaded_state():
+    brain = make_model_brain("text-planner")
+    brain.unload()
+    assert brain.loaded is False
+
+
+def test_an_unknown_brain_name_is_refused_with_the_alternatives():
+    with pytest.raises(BrainError, match="unknown brain"):
+        make_model_brain("gpt-9")
+
+
+def test_the_text_planner_needs_an_index_but_the_vlm_does_not():
+    assert make_model_brain("text-planner").requires_index is True
+    assert make_model_brain("vlm").requires_index is False
+
+
+def test_the_model_runtime_report_is_a_pair():
+    ok, detail = model_dependencies()
+    assert isinstance(ok, bool) and detail
+
+
+def test_model_cached_is_false_for_a_model_that_cannot_exist():
+    assert model_cached("definitely/not-a-real-model") is False
+
+
+def test_device_and_dtype_are_chosen_without_a_gpu():
+    assert resolve_device("cpu") == "cpu"
+    assert pick_dtype("cpu") is not None
+    assert pick_dtype("cuda") is not None