@mseep/open-computer-use 1.0.0

package/tests/orchestrator/test_docker_manager.py

@@ -0,0 +1,302 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""Tests for docker_manager._create_container env-injection behaviour.
+
+Covers the three operator paths from Phase 3 (GATEWAY-05) plus the
+ANTHROPIC_CUSTOM_HEADERS regression guard (GATEWAY-07) and the
+current_anthropic_base_url ContextVar default (GATEWAY-01).
+
+Run: cd computer-use-server && python -m pytest ../tests/orchestrator/test_docker_manager.py -v
+"""
+
+import os
+import sys
+import unittest
+import importlib
+import contextvars
+from unittest.mock import patch, MagicMock
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'computer-use-server'))
+
+from context_vars import (
+    current_chat_id,
+    current_user_email,
+    current_user_name,
+    current_gitlab_token,
+    current_gitlab_host,
+    current_anthropic_auth_token,
+    current_anthropic_base_url,
+)
+
+
+# Ten gateway model/flag vars injected via CLAUDE_CODE_PASSTHROUGH_ENVS
+GATEWAY_VAR_NAMES = (
+    "ANTHROPIC_MODEL",
+    "ANTHROPIC_DEFAULT_SONNET_MODEL",
+    "ANTHROPIC_DEFAULT_OPUS_MODEL",
+    "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+    "CLAUDE_CODE_SUBAGENT_MODEL",
+    "CLAUDE_CODE_DISABLE_EXPERIMENTAL_BETAS",
+    "DISABLE_PROMPT_CACHING",
+    "DISABLE_PROMPT_CACHING_SONNET",
+    "DISABLE_PROMPT_CACHING_OPUS",
+    "DISABLE_PROMPT_CACHING_HAIKU",
+)
+# The full set that a clean path-A env must not contain (12 keys total)
+ALL_GATEWAY_ENV_KEYS = GATEWAY_VAR_NAMES + ("ANTHROPIC_AUTH_TOKEN", "ANTHROPIC_BASE_URL")
+
+
+def _build_mock_docker_client():
+    """Return a MagicMock wired to satisfy the _create_container call path.
+
+    _create_container uses:
+      - client.containers.run(...)     — for the directory-setup ephemeral container
+      - client.containers.create(...)  — for the actual sandbox container (the assertion target)
+      - client.networks.get(...)       — for the compose-network attach (guarded by try/except)
+      - client.containers.get(...)     — for the ORCHESTRATOR_CONTAINER_NAME lookup (compose net)
+    """
+    client = MagicMock()
+    client.containers.run.return_value = None
+    client.containers.create.return_value = MagicMock()
+    # networks.list / volumes.list are not called by _create_container but harmless as defaults
+    client.networks.list.return_value = []
+    client.volumes.list.return_value = []
+    client.images.get.return_value = MagicMock()
+    return client
+
+
+def _reset_context_vars():
+    """Pin every ContextVar to a deterministic value to suppress cross-test leakage."""
+    current_chat_id.set("test-chat")
+    current_user_email.set(None)
+    current_user_name.set(None)
+    current_gitlab_token.set(None)
+    current_gitlab_host.set("gitlab.com")
+    current_anthropic_auth_token.set(None)
+    current_anthropic_base_url.set(None)
+
+
+def _clear_gateway_env():
+    """Pop every gateway-related env var from os.environ."""
+    for k in ALL_GATEWAY_ENV_KEYS:
+        os.environ.pop(k, None)
+
+
+class TestDockerManagerEnvInjection(unittest.TestCase):
+    """Three-path env-injection matrix + empty-string guard + ANTHROPIC_CUSTOM_HEADERS regression."""
+
+    def _reload_docker_manager(self, overrides):
+        """Apply a clean env matrix (clear gateway vars, apply overrides) and reload the module.
+
+        Returns the reloaded docker_manager module. Caller is responsible for using the
+        patch.dict context manager that wraps this method.
+        """
+        _clear_gateway_env()
+        for k, v in overrides.items():
+            os.environ[k] = v
+        import docker_manager
+        importlib.reload(docker_manager)
+        return docker_manager
+
+    def _run_isolated(self, body):
+        """Run `body` inside a fresh contextvars.Context so .set() calls do not leak to sibling tests.
+
+        `body` is a callable that takes no args and performs the test steps. Any ContextVar
+        mutations (e.g. current_chat_id.set("test-chat")) are confined to this Context copy.
+        """
+        fresh_ctx = contextvars.Context()
+        return fresh_ctx.run(body)
+
+    def test_path_a_zero_config_injects_no_gateway_vars(self):
+        """Path A: no ANTHROPIC_*/CLAUDE_CODE_* env vars on host -> no such keys in extra_env."""
+        def body():
+            with patch.dict(os.environ, {}, clear=False):
+                docker_manager = self._reload_docker_manager({})
+                _reset_context_vars()
+                client = _build_mock_docker_client()
+                with patch("docker_manager.get_docker_client", return_value=client):
+                    docker_manager._create_container("test-chat", "owui-chat-test")
+
+                env_dict = client.containers.create.call_args.kwargs["environment"]
+                for key in ALL_GATEWAY_ENV_KEYS:
+                    self.assertNotIn(key, env_dict, f"{key} leaked into zero-config path")
+        self._run_isolated(body)
+
+    def test_path_b_auth_only_injects_token_and_default_base_url(self):
+        """Path B: ANTHROPIC_AUTH_TOKEN only -> token + default https://api.anthropic.com base URL."""
+        def body():
+            with patch.dict(os.environ, {}, clear=False):
+                docker_manager = self._reload_docker_manager(
+                    {"ANTHROPIC_AUTH_TOKEN": "sk-EXAMPLE-path-b"}
+                )
+                _reset_context_vars()
+                client = _build_mock_docker_client()
+                with patch("docker_manager.get_docker_client", return_value=client):
+                    docker_manager._create_container("test-chat", "owui-chat-test")
+
+                env_dict = client.containers.create.call_args.kwargs["environment"]
+                self.assertEqual(env_dict["ANTHROPIC_AUTH_TOKEN"], "sk-EXAMPLE-path-b")
+                self.assertEqual(env_dict["ANTHROPIC_BASE_URL"], "https://api.anthropic.com")
+                for name in GATEWAY_VAR_NAMES:
+                    self.assertNotIn(name, env_dict, f"{name} leaked into auth-only path B")
+        self._run_isolated(body)
+
+    def test_path_c_custom_gateway_injects_all_twelve_keys(self):
+        """Path C: token + base URL + all ten gateway vars -> all twelve keys present with exact values."""
+        def body():
+            overrides = {
+                "ANTHROPIC_AUTH_TOKEN": "sk-EXAMPLE-path-c",
+                "ANTHROPIC_BASE_URL": "https://litellm.internal/",
+            }
+            for name in GATEWAY_VAR_NAMES:
+                overrides[name] = f"TEST_{name}"
+
+            with patch.dict(os.environ, {}, clear=False):
+                docker_manager = self._reload_docker_manager(overrides)
+                _reset_context_vars()
+                client = _build_mock_docker_client()
+                with patch("docker_manager.get_docker_client", return_value=client):
+                    docker_manager._create_container("test-chat", "owui-chat-test")
+
+                env_dict = client.containers.create.call_args.kwargs["environment"]
+                self.assertEqual(env_dict["ANTHROPIC_AUTH_TOKEN"], "sk-EXAMPLE-path-c")
+                self.assertEqual(env_dict["ANTHROPIC_BASE_URL"], "https://litellm.internal/")
+                for name in GATEWAY_VAR_NAMES:
+                    self.assertEqual(
+                        env_dict[name],
+                        f"TEST_{name}",
+                        f"{name} value mismatch in custom-gateway path",
+                    )
+        self._run_isolated(body)
+
+    def test_empty_string_env_vars_are_not_injected(self):
+        """Empty-string env vars must be skipped by the `if _value:` guard."""
+        def body():
+            overrides = {
+                "ANTHROPIC_AUTH_TOKEN": "sk-EXAMPLE-empty-guard",
+                "ANTHROPIC_MODEL": "",  # explicit empty string
+            }
+            with patch.dict(os.environ, {}, clear=False):
+                docker_manager = self._reload_docker_manager(overrides)
+                _reset_context_vars()
+                client = _build_mock_docker_client()
+                with patch("docker_manager.get_docker_client", return_value=client):
+                    docker_manager._create_container("test-chat", "owui-chat-test")
+
+                env_dict = client.containers.create.call_args.kwargs["environment"]
+                self.assertNotIn("ANTHROPIC_MODEL", env_dict)
+                # other nine gateway names also absent — none were set
+                for name in GATEWAY_VAR_NAMES:
+                    self.assertNotIn(name, env_dict, f"{name} unexpectedly present")
+        self._run_isolated(body)
+
+    def test_anthropic_custom_headers_injection_regression_guard(self):
+        """current_user_email set -> ANTHROPIC_CUSTOM_HEADERS + GIT_* vars land unchanged."""
+        def body():
+            with patch.dict(os.environ, {}, clear=False):
+                docker_manager = self._reload_docker_manager(
+                    {"ANTHROPIC_AUTH_TOKEN": "sk-EXAMPLE-headers"}
+                )
+                _reset_context_vars()
+                current_user_email.set("alice@example.com")
+                client = _build_mock_docker_client()
+                with patch("docker_manager.get_docker_client", return_value=client):
+                    docker_manager._create_container("test-chat", "owui-chat-test")
+
+                env_dict = client.containers.create.call_args.kwargs["environment"]
+                self.assertEqual(
+                    env_dict["ANTHROPIC_CUSTOM_HEADERS"],
+                    "x-openwebui-user-email: alice@example.com",
+                )
+                self.assertEqual(env_dict["GIT_AUTHOR_EMAIL"], "alice@example.com")
+                self.assertEqual(env_dict["GIT_COMMITTER_EMAIL"], "alice@example.com")
+        self._run_isolated(body)
+
+
+class TestContextVarAnthropicBaseUrlDefault(unittest.TestCase):
+    """GATEWAY-01 unit test: ContextVar default must be None so the `or` fallback fires."""
+
+    def test_current_anthropic_base_url_default_is_none_after_reload(self):
+        """ContextVar must declare default=None so .get() returns None when unset.
+
+        We do NOT reload context_vars here — reloading creates a new ContextVar
+        singleton that other already-loaded modules no longer reference, which
+        pollutes sibling test files. Instead, we run the .get() inside a fresh
+        copy_context() so any prior .set() from other tests does not leak in,
+        then assert the declared default is None.
+        """
+        import contextvars
+        import context_vars as cv_mod
+
+        # Inspect the default directly without touching live context state.
+        # This avoids cross-test pollution from any prior .set() calls.
+        fresh_ctx = contextvars.Context()
+        value = fresh_ctx.run(cv_mod.current_anthropic_base_url.get)
+        self.assertIsNone(value)
+
+
+class TestBuildMcpConfigBaseUrlFallback(unittest.TestCase):
+    """Regression guard: build_mcp_config must accept None/empty base_url.
+
+    Before the fix, callers in sub_agent (mcp_tools.py) and _create_container
+    (docker_manager.py) passed current_anthropic_base_url.get() directly —
+    which became None after the GATEWAY-01 ContextVar default change.
+    That hit base_url.rstrip("/") and raised AttributeError, silently
+    disabling MCP config write on the "MCP servers configured but no
+    base-url header" path.
+    """
+
+    def _reload_docker_manager(self):
+        import docker_manager
+        importlib.reload(docker_manager)
+        return docker_manager
+
+    def test_none_base_url_falls_back_to_module_constant(self):
+        """None base_url: config builds successfully, uses module default."""
+        dm = self._reload_docker_manager()
+        cfg = dm.build_mcp_config("metabase", None, user_email="alice@example.com")
+        self.assertIsNotNone(cfg)
+        self.assertIn("metabase", cfg["mcpServers"])
+        url = cfg["mcpServers"]["metabase"]["url"]
+        self.assertTrue(url.endswith("/mcp/metabase"))
+        # Module default is https://api.anthropic.com (set by our getenv-or-literal pattern)
+        self.assertTrue(url.startswith("http"))
+
+    def test_empty_string_base_url_falls_back_to_module_constant(self):
+        """Empty-string base_url: same fallback path as None — covers the
+        compose ${VAR:-} scenario that leaves the env set but empty."""
+        dm = self._reload_docker_manager()
+        cfg = dm.build_mcp_config("metabase", "", user_email="alice@example.com")
+        self.assertIsNotNone(cfg)
+        self.assertTrue(cfg["mcpServers"]["metabase"]["url"].endswith("/mcp/metabase"))
+
+    def test_explicit_base_url_overrides_module_constant(self):
+        """When caller provides a non-empty base_url, it wins (with trailing / stripped)."""
+        dm = self._reload_docker_manager()
+        cfg = dm.build_mcp_config(
+            "metabase",
+            "https://litellm.internal/",
+            user_email="alice@example.com",
+        )
+        self.assertIsNotNone(cfg)
+        self.assertEqual(
+            cfg["mcpServers"]["metabase"]["url"],
+            "https://litellm.internal/mcp/metabase",
+        )
+
+
+class TestAnthropicBaseUrlEmptyStringHandling(unittest.TestCase):
+    """Empty env vars from compose ${VAR:-} must not override the module default."""
+
+    def test_empty_env_treats_as_unset_for_anthropic_base_url(self):
+        """docker-compose ${ANTHROPIC_BASE_URL:-} sets the var to "", which
+        os.getenv returns as "" (not the default). The module falls back to
+        the public Anthropic URL via `os.getenv(...) or "https://..."`."""
+        with patch.dict(os.environ, {"ANTHROPIC_BASE_URL": ""}, clear=False):
+            import docker_manager
+            importlib.reload(docker_manager)
+            self.assertEqual(docker_manager.ANTHROPIC_BASE_URL, "https://api.anthropic.com")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/orchestrator/test_dynamic_instructions.py

@@ -0,0 +1,69 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""
+Tier 4 — InitializeResult.instructions must be dynamic per-request via the
+current_instructions ContextVar.
+
+The ContextVar-driven property lives on a subclass of the lowlevel MCP Server
+that was swapped onto mcp._mcp_server after FastMCP(...) constructed it. This
+test exercises the property directly rather than spinning up a full HTTP
+InitializeRequest — cheaper, same load-bearing guarantee.
+"""
+import sys
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent.parent
+sys.path.insert(0, str(ROOT / "computer-use-server"))
+
+import mcp_tools  # noqa: E402
+from context_vars import current_instructions  # noqa: E402
+
+
+class DynamicInstructionsContract(unittest.TestCase):
+    def test_class_was_swapped(self):
+        self.assertEqual(
+            mcp_tools.mcp._mcp_server.__class__.__name__,
+            "_DynamicInstructionsServer",
+            "mcp._mcp_server class swap did not happen at import time",
+        )
+
+    def test_static_fallback_when_contextvar_unset(self):
+        # Sanity: with no ContextVar, we get the static string
+        tok = current_instructions.set(None)
+        try:
+            v = mcp_tools.mcp._mcp_server.instructions
+            self.assertIn("README.md", v)
+            self.assertIn("resources/list", v)
+        finally:
+            current_instructions.reset(tok)
+
+    def test_contextvar_value_wins(self):
+        tok = current_instructions.set("PER-CHAT-DEMO")
+        try:
+            self.assertEqual(
+                mcp_tools.mcp._mcp_server.instructions,
+                "PER-CHAT-DEMO",
+            )
+        finally:
+            current_instructions.reset(tok)
+
+    def test_distinct_contextvar_values_return_distinct_instructions(self):
+        t1 = current_instructions.set("chat-alpha")
+        try:
+            a = mcp_tools.mcp._mcp_server.instructions
+        finally:
+            current_instructions.reset(t1)
+
+        t2 = current_instructions.set("chat-beta")
+        try:
+            b = mcp_tools.mcp._mcp_server.instructions
+        finally:
+            current_instructions.reset(t2)
+
+        self.assertEqual(a, "chat-alpha")
+        self.assertEqual(b, "chat-beta")
+
+
+if __name__ == "__main__":
+    unittest.main()

package/tests/orchestrator/test_mcp_resources.py

@@ -0,0 +1,140 @@
+# SPDX-License-Identifier: FSL-1.1-Apache-2.0
+# Copyright (c) 2025 Open Computer Use Contributors
+"""
+Tier 6 — uploaded files as MCP resources.
+
+Exercises:
+  - sync_chat_resources + list_resources for flat and nested paths
+  - read_resource returning text for text/*, bytes for everything else
+  - tenancy: a fresh chat has no inherited resources
+  - idempotent re-sync (no duplicate registrations)
+  - concurrency safety: sync while list_resources iterates
+"""
+import asyncio
+import os
+import shutil
+import sys
+import tempfile
+import unittest
+from pathlib import Path
+
+ROOT = Path(__file__).resolve().parent.parent.parent
+
+
+class McpResourcesContract(unittest.TestCase):
+    """Needs BASE_DATA_DIR set BEFORE uploads/mcp_resources are imported."""
+
+    @classmethod
+    def setUpClass(cls):
+        cls._tmp = tempfile.mkdtemp(prefix="ocu-resource-test-")
+        os.environ["BASE_DATA_DIR"] = cls._tmp
+
+        sys.path.insert(0, str(ROOT / "computer-use-server"))
+        # Fresh imports so BASE_DATA_DIR is picked up
+        import uploads as uploads_mod
+        import importlib
+        importlib.reload(uploads_mod)
+
+        import mcp_tools  # noqa: F401 — the singleton
+        import mcp_resources as mr
+        importlib.reload(mr)
+
+        cls.mcp_tools = mcp_tools
+        cls.mcp_resources = mr
+        cls.uploads = uploads_mod
+
+    @classmethod
+    def tearDownClass(cls):
+        shutil.rmtree(cls._tmp, ignore_errors=True)
+
+    def _make_upload(self, chat_id: str, rel_path: str, content: str):
+        target = Path(self._tmp) / chat_id / "uploads" / rel_path
+        target.parent.mkdir(parents=True, exist_ok=True)
+        target.write_text(content)
+
+    def test_flat_and_nested_list_read(self):
+        self._make_upload("demoa", "hello.txt", "hi")
+        self._make_upload("demoa", "sub/nested.json", '{"k":1}')
+        n = asyncio.run(self.mcp_resources.sync_chat_resources("demoa"))
+        self.assertEqual(n, 2)
+
+        resources = asyncio.run(self.mcp_tools.mcp.list_resources())
+        uris = {str(r.uri) for r in resources}
+        self.assertIn("file://uploads/demoa/hello.txt", uris)
+        self.assertIn("file://uploads/demoa/sub%2Fnested.json", uris)
+
+        from pydantic import AnyUrl
+        flat = list(asyncio.run(self.mcp_tools.mcp.read_resource(
+            AnyUrl("file://uploads/demoa/hello.txt"))))
+        self.assertEqual(flat[0].content, "hi")
+        nested = list(asyncio.run(self.mcp_tools.mcp.read_resource(
+            AnyUrl("file://uploads/demoa/sub%2Fnested.json"))))
+        self.assertEqual(nested[0].content, '{"k":1}')
+
+    def test_tenancy_empty_for_unknown_chat(self):
+        # Plant a real upload for tenant A so the global resource registry
+        # has at least one entry. Then assert tenant B sees ZERO resources
+        # AND the registry-level list contains tenant A's URI but not any
+        # tenant-B URI — proves there is no leak across chats via the
+        # shared FastMCP._resource_manager._resources dict.
+        self._make_upload("tenant-a", "secret.txt", "A-only")
+        asyncio.run(self.mcp_resources.sync_chat_resources("tenant-a"))
+
+        n = asyncio.run(self.mcp_resources.sync_chat_resources("tenant-b"))
+        self.assertEqual(n, 0)
+
+        all_uris = {
+            str(r.uri) for r in asyncio.run(self.mcp_tools.mcp.list_resources())
+        }
+        # Tenant A's resource must still be present (sync_chat_resources(B)
+        # must not have wiped A).
+        self.assertIn("file://uploads/tenant-a/secret.txt", all_uris)
+        # And NO resource URI should mention tenant-b.
+        leaked = [u for u in all_uris if "tenant-b" in u]
+        self.assertEqual(leaked, [], f"tenant-b leaked URIs: {leaked}")
+
+    def test_idempotent_resync(self):
+        self._make_upload("demob", "once.txt", "only")
+        asyncio.run(self.mcp_resources.sync_chat_resources("demob"))
+        asyncio.run(self.mcp_resources.sync_chat_resources("demob"))
+        resources = asyncio.run(self.mcp_tools.mcp.list_resources())
+        demob_uris = [r for r in resources if "demob" in str(r.uri)]
+        self.assertEqual(len(demob_uris), 1, "re-sync must not duplicate entries")
+
+    def test_concurrent_sync_and_list(self):
+        """Stress: sync + list in parallel. Without the lock around the
+        clear-then-rebuild, `dict changed size during iteration` fires."""
+        self._make_upload("democ", "a.txt", "A")
+        self._make_upload("democ", "b.txt", "B")
+
+        async def _stress():
+            await self.mcp_resources.sync_chat_resources("democ")
+            tasks = []
+            for _ in range(20):
+                tasks.append(self.mcp_resources.sync_chat_resources("democ"))
+                tasks.append(self.mcp_tools.mcp.list_resources())
+            results = await asyncio.gather(*tasks, return_exceptions=True)
+            for r in results:
+                if isinstance(r, Exception):
+                    raise r
+            return len(results)
+
+        n = asyncio.run(_stress())
+        self.assertEqual(n, 40)
+
+    def test_list_changed_notification_skipped_outside_request_context(self):
+        """sync_chat_resources is called from docker_manager._create_container
+        on a worker thread — no `request_ctx` is set, and we must NOT blow up.
+        Notification is silently skipped; fresh list still surfaces on the
+        next resources/list call."""
+        self._make_upload("demod", "skip.txt", "no ctx")
+        # Confirm we actually have no request context right now
+        from mcp.server.lowlevel.server import request_ctx
+        self.assertRaises(LookupError, request_ctx.get)
+        # Should not raise — graceful skip of the notification branch
+        n = asyncio.run(self.mcp_resources.sync_chat_resources("demod"))
+        self.assertEqual(n, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()