test: tighten phase 1 coverage contracts

tests/unit_tests/plugin/test_handler.py

@@ -6,9 +6,18 @@ Tests handler helper methods that don't require full handler setup.
 from __future__ import annotations
 
 from types import SimpleNamespace
-from unittest.mock import MagicMock
+from unittest.mock import AsyncMock, MagicMock, Mock
 import pytest
 
+from langbot_plugin.entities.io.actions.enums import PluginToRuntimeAction
+
+
+def make_handler(app):
+    """Create a RuntimeConnectionHandler with mocked external connection."""
+    from langbot.pkg.plugin.handler import RuntimeConnectionHandler
+
+    return RuntimeConnectionHandler(Mock(), AsyncMock(return_value=True), app)
+
 
 class TestHandlerQueryVariables:
     """Tests for handler query variable logic."""
@@ -29,65 +38,67 @@ class TestHandlerQueryVariables:
     @pytest.mark.asyncio
     async def test_set_query_var_query_not_found(self, mock_app):
         """Test set_query_var returns error when query not found."""
-        query_id = 'nonexistent-query'
+        runtime_handler = make_handler(mock_app)
 
-        if query_id not in mock_app.query_pool.cached_queries:
-            expected_error = f'Query with query_id {query_id} not found'
-            # Should return error response
-            assert expected_error is not None
+        response = await runtime_handler.actions[PluginToRuntimeAction.SET_QUERY_VAR.value]({
+            'query_id': 'nonexistent-query',
+            'key': 'test_var',
+            'value': 'test_value',
+        })
+
+        assert response.code != 0
+        assert 'nonexistent-query' in response.message
 
     @pytest.mark.asyncio
     async def test_set_query_var_success(self, mock_app):
         """Test set_query_var sets variable on existing query."""
+        runtime_handler = make_handler(mock_app)
         mock_query = SimpleNamespace()
         mock_query.variables = {}
 
         mock_app.query_pool.cached_queries['test-query'] = mock_query
 
-        # Simulate set_query_var logic
-        query_id = 'test-query'
-        var_name = 'test_var'
-        var_value = 'test_value'
-
-        if query_id in mock_app.query_pool.cached_queries:
-            query = mock_app.query_pool.cached_queries[query_id]
-            query.variables[var_name] = var_value
+        response = await runtime_handler.actions[PluginToRuntimeAction.SET_QUERY_VAR.value]({
+            'query_id': 'test-query',
+            'key': 'test_var',
+            'value': 'test_value',
+        })
 
+        assert response.code == 0
         assert mock_query.variables['test_var'] == 'test_value'
 
     @pytest.mark.asyncio
     async def test_get_query_var_success(self, mock_app):
         """Test get_query_var retrieves variable from query."""
+        runtime_handler = make_handler(mock_app)
         mock_query = SimpleNamespace()
         mock_query.variables = {'existing_var': 'existing_value'}
 
         mock_app.query_pool.cached_queries['test-query'] = mock_query
 
-        # Simulate get_query_var logic
-        query_id = 'test-query'
-        var_name = 'existing_var'
+        response = await runtime_handler.actions[PluginToRuntimeAction.GET_QUERY_VAR.value]({
+            'query_id': 'test-query',
+            'key': 'existing_var',
+        })
 
-        if query_id in mock_app.query_pool.cached_queries:
-            query = mock_app.query_pool.cached_queries[query_id]
-            if var_name in query.variables:
-                value = query.variables[var_name]
-                assert value == 'existing_value'
+        assert response.code == 0
+        assert response.data == {'value': 'existing_value'}
 
     @pytest.mark.asyncio
     async def test_get_query_vars_multiple(self, mock_app):
-        """Test get_query_vars retrieves multiple variables."""
+        """Test get_query_vars returns the query's variable mapping."""
+        runtime_handler = make_handler(mock_app)
         mock_query = SimpleNamespace()
         mock_query.variables = {'var1': 'val1', 'var2': 'val2', 'var3': 'val3'}
 
         mock_app.query_pool.cached_queries['test-query'] = mock_query
 
-        query_id = 'test-query'
-        var_names = ['var1', 'var3']
+        response = await runtime_handler.actions[PluginToRuntimeAction.GET_QUERY_VARS.value]({
+            'query_id': 'test-query',
+        })
 
-        if query_id in mock_app.query_pool.cached_queries:
-            query = mock_app.query_pool.cached_queries[query_id]
-            result = {name: query.variables.get(name) for name in var_names}
-            assert result == {'var1': 'val1', 'var3': 'val3'}
+        assert response.code == 0
+        assert response.data == {'vars': mock_query.variables}
 
 
 class TestHandlerRagErrorResponse:
@@ -95,7 +106,7 @@ class TestHandlerRagErrorResponse:
 
     def test_make_rag_error_response_basic(self):
         """Test basic error response creation."""
-        from src.langbot.pkg.plugin.handler import _make_rag_error_response
+        from langbot.pkg.plugin.handler import _make_rag_error_response
 
         error = Exception("test error")
         response = _make_rag_error_response(error, 'TestError')
@@ -107,7 +118,7 @@ class TestHandlerRagErrorResponse:
 
     def test_make_rag_error_response_with_context(self):
         """Test error response with extra context."""
-        from src.langbot.pkg.plugin.handler import _make_rag_error_response
+        from langbot.pkg.plugin.handler import _make_rag_error_response
 
         error = ValueError("invalid input")
         response = _make_rag_error_response(
@@ -124,7 +135,7 @@ class TestHandlerRagErrorResponse:
 
     def test_make_rag_error_response_exception_type(self):
         """Test error response includes exception type."""
-        from src.langbot.pkg.plugin.handler import _make_rag_error_response
+        from langbot.pkg.plugin.handler import _make_rag_error_response
 
         error = RuntimeError("connection failed")
         response = _make_rag_error_response(error, 'ConnectionError')
@@ -135,7 +146,7 @@ class TestHandlerRagErrorResponse:
 
     def test_make_rag_error_response_empty_context(self):
         """Test error response with no extra context."""
-        from src.langbot.pkg.plugin.handler import _make_rag_error_response
+        from langbot.pkg.plugin.handler import _make_rag_error_response
 
         error = KeyError("missing_key")
         response = _make_rag_error_response(error, 'LookupError')
@@ -150,21 +161,21 @@ class TestConstantsSemanticVersion:
 
     def test_semantic_version_exists(self):
         """Test semantic_version is defined."""
-        from src.langbot.pkg.utils import constants
+        from langbot.pkg.utils import constants
 
         assert hasattr(constants, 'semantic_version')
         assert constants.semantic_version.startswith('v')
 
     def test_edition_exists(self):
         """Test edition constant is defined."""
-        from src.langbot.pkg.utils import constants
+        from langbot.pkg.utils import constants
 
         assert hasattr(constants, 'edition')
         assert constants.edition == 'community'
 
     def test_required_database_version_exists(self):
         """Test database version constant."""
-        from src.langbot.pkg.utils import constants
+        from langbot.pkg.utils import constants
 
         assert hasattr(constants, 'required_database_version')
-        assert isinstance(constants.required_database_version, int)
+        assert isinstance(constants.required_database_version, int)