Skip to content

:hedgehog: PostHog is the leading platform for building self-driving products. Our developer tools – AI observability, analytics, session replay, flags, experiments, error tracking, logs, and more – capture all the context agents need to diagnose problems, uncover opportunities, and ship fixes. Steer it all from Slack, web, desktop, or the MCP.

18.6 KB
Raw Blame
"""
Comprehensive tests for AssistantDispatcher.

Tests the dispatcher logic that emits actions to LangGraph custom stream.
"""

from posthog.test.base import BaseTest
from unittest.mock import MagicMock, patch

from django.test import SimpleTestCase

from langchain_core.runnables import RunnableConfig

from posthog.schema import AssistantMessage, AssistantToolCall

from ee.hogai.utils.dispatcher import AssistantDispatcher, create_dispatcher_from_config
from ee.hogai.utils.types.base import (
    AssistantDispatcherEvent,
    AssistantGraphName,
    AssistantNodeName,
    MessageAction,
    NodePath,
    UpdateAction,
)


class TestAssistantDispatcher(BaseTest):
    """Test the AssistantDispatcher in isolation."""

    def setUp(self):
        super().setUp()
        self.dispatched_events: list[AssistantDispatcherEvent] = []

        def mock_writer(event):
            self.dispatched_events.append(event)

        self.writer = mock_writer
        self.node_path = (
            NodePath(name=AssistantGraphName.ASSISTANT),
            NodePath(name=AssistantNodeName.ROOT),
        )

    def test_create_dispatcher_with_basic_params(self):
        """Test creating a dispatcher with required parameters."""
        dispatcher = AssistantDispatcher(
            writer=self.writer,
            node_path=self.node_path,
            node_name=AssistantNodeName.ROOT,
            node_run_id="test_run_123",
        )

        self.assertEqual(dispatcher._node_name, AssistantNodeName.ROOT)
        self.assertEqual(dispatcher._node_run_id, "test_run_123")
        self.assertEqual(dispatcher._node_path, self.node_path)
        self.assertEqual(dispatcher._writer, self.writer)

    def test_dispatch_message_action(self):
        """Test dispatching a message via the message() method."""
        dispatcher = AssistantDispatcher(
            writer=self.writer,
            node_path=self.node_path,
            node_name=AssistantNodeName.ROOT,
            node_run_id="test_run_456",
        )

        message = AssistantMessage(content="Test message")
        dispatcher.message(message)

        self.assertEqual(len(self.dispatched_events), 1)
        event = self.dispatched_events[0]

        self.assertIsInstance(event, AssistantDispatcherEvent)
        self.assertIsInstance(event.action, MessageAction)
        assert isinstance(event.action, MessageAction)
        self.assertEqual(event.action.message, message)
        self.assertEqual(event.node_name, AssistantNodeName.ROOT)
        self.assertEqual(event.node_run_id, "test_run_456")
        self.assertEqual(event.node_path, self.node_path)

    def test_dispatch_update_action(self):
        """Test dispatching an update via the update() method."""
        dispatcher = AssistantDispatcher(
            writer=self.writer,
            node_path=self.node_path,
            node_name=AssistantNodeName.TRENDS_GENERATOR,
            node_run_id="test_run_789",
        )

        dispatcher.update("Processing query...")

        self.assertEqual(len(self.dispatched_events), 1)
        event = self.dispatched_events[0]

        self.assertIsInstance(event, AssistantDispatcherEvent)
        self.assertIsInstance(event.action, UpdateAction)
        assert isinstance(event.action, UpdateAction)
        self.assertEqual(event.action.content, "Processing query...")
        self.assertEqual(event.node_name, AssistantNodeName.TRENDS_GENERATOR)
        self.assertEqual(event.node_run_id, "test_run_789")

    def test_dispatch_update_action_with_tool_call(self):
        """Test dispatching an update with an AssistantToolCall content."""
        dispatcher = AssistantDispatcher(
            writer=self.writer,
            node_path=self.node_path,
            node_name=AssistantNodeName.TRENDS_GENERATOR,
            node_run_id="test_run_tool_call",
        )

        tool_call = AssistantToolCall(id="tc_1", name="some_tool", args={"key": "value"})
        dispatcher.update(content=tool_call)

        self.assertEqual(len(self.dispatched_events), 1)
        event = self.dispatched_events[0]

        self.assertIsInstance(event, AssistantDispatcherEvent)
        self.assertIsInstance(event.action, UpdateAction)
        assert isinstance(event.action, UpdateAction)
        self.assertEqual(event.action.content, tool_call)
        self.assertEqual(event.node_name, AssistantNodeName.TRENDS_GENERATOR)
        self.assertEqual(event.node_run_id, "test_run_tool_call")

    def test_dispatch_multiple_messages(self):
        """Test dispatching multiple messages in sequence."""
        dispatcher = AssistantDispatcher(
            writer=self.writer,
            node_path=self.node_path,
            node_name=AssistantNodeName.ROOT,
            node_run_id="test_run_multi",
        )

        message1 = AssistantMessage(content="First message")
        message2 = AssistantMessage(content="Second message")
        message3 = AssistantMessage(content="Third message")

        dispatcher.message(message1)
        dispatcher.message(message2)
        dispatcher.message(message3)

        self.assertEqual(len(self.dispatched_events), 3)

        contents = []
        for event in self.dispatched_events:
            if isinstance(event.action, MessageAction):
                msg = event.action.message
                if isinstance(msg, AssistantMessage):
                    contents.append(msg.content)
        self.assertEqual(contents, ["First message", "Second message", "Third message"])

    def test_dispatch_message_with_tool_calls(self):
        """Test dispatching a message with tool calls preserves all data."""
        dispatcher = AssistantDispatcher(
            writer=self.writer,
            node_path=self.node_path,
            node_name=AssistantNodeName.ROOT,
            node_run_id="test_run_tools",
        )

        tool_call = AssistantToolCall(id="tool_123", name="search", args={"query": "test query"})
        message = AssistantMessage(content="Running search...", tool_calls=[tool_call])

        dispatcher.message(message)

        self.assertEqual(len(self.dispatched_events), 1)
        event = self.dispatched_events[0]

        self.assertIsInstance(event.action, MessageAction)
        assert isinstance(event.action, MessageAction)
        dispatched_message = event.action.message
        assert isinstance(dispatched_message, AssistantMessage)
        self.assertEqual(dispatched_message.content, "Running search...")
        self.assertIsNotNone(dispatched_message.tool_calls)
        assert dispatched_message.tool_calls is not None
        self.assertEqual(len(dispatched_message.tool_calls), 1)
        self.assertEqual(dispatched_message.tool_calls[0].id, "tool_123")
        self.assertEqual(dispatched_message.tool_calls[0].name, "search")
        self.assertEqual(dispatched_message.tool_calls[0].args, {"query": "test query"})

    def test_dispatch_with_nested_node_path(self):
        """Test that nested node paths are preserved in dispatched events."""
        nested_path = (
            NodePath(name=AssistantGraphName.ASSISTANT),
            NodePath(name=AssistantNodeName.ROOT, message_id="msg_123", tool_call_id="tc_123"),
            NodePath(name=AssistantGraphName.INSIGHTS),
            NodePath(name=AssistantNodeName.TRENDS_GENERATOR),
        )

        dispatcher = AssistantDispatcher(
            writer=self.writer, node_path=nested_path, node_name=AssistantNodeName.TRENDS_GENERATOR, node_run_id="run_1"
        )

        message = AssistantMessage(content="Nested message")
        dispatcher.message(message)

        self.assertEqual(len(self.dispatched_events), 1)
        event = self.dispatched_events[0]

        self.assertEqual(event.node_path, nested_path)
        assert event.node_path is not None
        self.assertEqual(len(event.node_path), 4)
        self.assertEqual(event.node_path[1].message_id, "msg_123")
        self.assertEqual(event.node_path[1].tool_call_id, "tc_123")

    def test_dispatch_error_handling_continues_execution(self):
        """Test that dispatch errors are caught and logged but don't crash."""

        def failing_writer(event):
            raise RuntimeError("Writer failed!")

        dispatcher = AssistantDispatcher(
            writer=failing_writer,
            node_path=self.node_path,
            node_name=AssistantNodeName.ROOT,
            node_run_id="test_run_error",
        )

        message = AssistantMessage(content="This should not crash")

        # Should not raise exception
        with patch("logging.getLogger") as mock_get_logger:
            mock_logger = MagicMock()
            mock_get_logger.return_value = mock_logger

            dispatcher.message(message)

            # Verify error was logged
            mock_logger.error.assert_called_once()
            args, kwargs = mock_logger.error.call_args
            self.assertIn("Failed to dispatch action", args[0])

    def test_dispatch_mixed_actions(self):
        """Test dispatching both messages and updates in sequence."""
        dispatcher = AssistantDispatcher(
            writer=self.writer,
            node_path=self.node_path,
            node_name=AssistantNodeName.TRENDS_GENERATOR,
            node_run_id="test_run_mixed",
        )

        dispatcher.update("Starting analysis...")
        dispatcher.message(AssistantMessage(content="Found 3 insights"))
        dispatcher.update("Finalizing results...")

        self.assertEqual(len(self.dispatched_events), 3)

        self.assertIsInstance(self.dispatched_events[0].action, UpdateAction)
        assert isinstance(self.dispatched_events[0].action, UpdateAction)
        self.assertEqual(self.dispatched_events[0].action.content, "Starting analysis...")

        self.assertIsInstance(self.dispatched_events[1].action, MessageAction)
        assert isinstance(self.dispatched_events[1].action, MessageAction)
        assert isinstance(self.dispatched_events[1].action.message, AssistantMessage)
        self.assertEqual(self.dispatched_events[1].action.message.content, "Found 3 insights")

        self.assertIsInstance(self.dispatched_events[2].action, UpdateAction)
        assert isinstance(self.dispatched_events[2].action, UpdateAction)
        self.assertEqual(self.dispatched_events[2].action.content, "Finalizing results...")

    def test_dispatch_preserves_message_id(self):
        """Test that message IDs are preserved through dispatch."""
        dispatcher = AssistantDispatcher(
            writer=self.writer,
            node_path=self.node_path,
            node_name=AssistantNodeName.ROOT,
            node_run_id="test_run_id_preservation",
        )

        message = AssistantMessage(id="msg_xyz_789", content="Message with ID")
        dispatcher.message(message)

        event = self.dispatched_events[0]
        assert isinstance(event.action, MessageAction)
        self.assertEqual(event.action.message.id, "msg_xyz_789")

    def test_dispatch_with_empty_node_path(self):
        """Test dispatcher with an empty node path."""
        dispatcher = AssistantDispatcher(
            writer=self.writer, node_path=(), node_name=AssistantNodeName.ROOT, node_run_id="test_run_empty_path"
        )

        message = AssistantMessage(content="Root level message")
        dispatcher.message(message)

        self.assertEqual(len(self.dispatched_events), 1)
        event = self.dispatched_events[0]
        self.assertEqual(event.node_path, ())


class TestCreateDispatcherFromConfig(BaseTest):
    """Test the create_dispatcher_from_config helper function."""

    def test_create_dispatcher_from_config_with_stream_writer(self):
        """Test creating dispatcher from config with LangGraph stream writer."""
        node_path = (NodePath(name=AssistantGraphName.ASSISTANT), NodePath(name=AssistantNodeName.ROOT))

        config = RunnableConfig(
            metadata={"langgraph_node": AssistantNodeName.TRENDS_GENERATOR, "langgraph_checkpoint_ns": "checkpoint_abc"}
        )

        mock_writer = MagicMock()

        with patch("ee.hogai.utils.dispatcher.get_stream_writer", return_value=mock_writer):
            dispatcher = create_dispatcher_from_config(config, node_path)

            self.assertEqual(dispatcher._node_name, AssistantNodeName.TRENDS_GENERATOR)
            self.assertEqual(dispatcher._node_run_id, "checkpoint_abc")
            self.assertEqual(dispatcher._node_path, node_path)
            self.assertEqual(dispatcher._writer, mock_writer)

    def test_create_dispatcher_from_config_without_stream_writer(self):
        """Test creating dispatcher when not in streaming context (e.g., testing)."""
        node_path = (NodePath(name=AssistantGraphName.ASSISTANT), NodePath(name=AssistantNodeName.ROOT))

        config = RunnableConfig(
            metadata={"langgraph_node": AssistantNodeName.ROOT, "langgraph_checkpoint_ns": "checkpoint_xyz"}
        )

        # Simulate RuntimeError when get_stream_writer is called outside streaming context
        with patch("ee.hogai.utils.dispatcher.get_stream_writer", side_effect=RuntimeError("Not in streaming context")):
            dispatcher = create_dispatcher_from_config(config, node_path)

            # Should create a noop writer
            self.assertEqual(dispatcher._node_name, AssistantNodeName.ROOT)
            self.assertEqual(dispatcher._node_run_id, "checkpoint_xyz")
            self.assertEqual(dispatcher._node_path, node_path)

            # Verify the noop writer doesn't raise exceptions
            message = AssistantMessage(content="Test")
            dispatcher.message(message)  # Should not crash

    def test_create_dispatcher_with_missing_metadata(self):
        """Test creating dispatcher when metadata fields are missing."""
        node_path = (NodePath(name=AssistantGraphName.ASSISTANT),)

        config = RunnableConfig(metadata={})

        with patch("ee.hogai.utils.dispatcher.get_stream_writer", side_effect=RuntimeError("Not in streaming context")):
            dispatcher = create_dispatcher_from_config(config, node_path)

            # Should use empty strings as defaults
            self.assertEqual(dispatcher._node_name, "")
            self.assertEqual(dispatcher._node_run_id, "")
            self.assertEqual(dispatcher._node_path, node_path)

    def test_create_dispatcher_preserves_node_path(self):
        """Test that node path is correctly passed through to the dispatcher."""
        nested_path = (
            NodePath(name=AssistantGraphName.ASSISTANT),
            NodePath(name=AssistantNodeName.ROOT, message_id="msg_1", tool_call_id="tc_1"),
            NodePath(name=AssistantGraphName.INSIGHTS),
        )

        config = RunnableConfig(
            metadata={"langgraph_node": AssistantNodeName.TRENDS_GENERATOR, "langgraph_checkpoint_ns": "cp_1"}
        )

        with patch("ee.hogai.utils.dispatcher.get_stream_writer", side_effect=RuntimeError("Not in streaming context")):
            dispatcher = create_dispatcher_from_config(config, nested_path)

            self.assertEqual(dispatcher._node_path, nested_path)
            self.assertEqual(len(dispatcher._node_path), 3)


class TestDispatcherIntegration(SimpleTestCase):
    """Integration tests for dispatcher usage patterns."""

    def test_dispatcher_in_node_context(self):
        """Test typical usage pattern within a node."""
        dispatched_events = []

        def mock_writer(event):
            dispatched_events.append(event)

        node_path = (
            NodePath(name=AssistantGraphName.ASSISTANT),
            NodePath(name=AssistantNodeName.ROOT),
        )

        dispatcher = AssistantDispatcher(
            writer=mock_writer, node_path=node_path, node_name=AssistantNodeName.ROOT, node_run_id="integration_run_1"
        )

        # Simulate node execution pattern
        dispatcher.update("Starting node execution...")

        tool_call = AssistantToolCall(id="tc_int_1", name="generate_insight", args={"type": "trends"})
        dispatcher.message(AssistantMessage(content="Generating insight", tool_calls=[tool_call]))

        dispatcher.update("Processing data...")

        dispatcher.message(AssistantMessage(content="Insight generated successfully"))

        # Verify all events were dispatched
        self.assertEqual(len(dispatched_events), 4)

        # Verify event types and order
        self.assertIsInstance(dispatched_events[0].action, UpdateAction)
        self.assertIsInstance(dispatched_events[1].action, MessageAction)
        self.assertIsInstance(dispatched_events[2].action, UpdateAction)
        self.assertIsInstance(dispatched_events[3].action, MessageAction)

        # Verify all events have consistent metadata
        for event in dispatched_events:
            self.assertEqual(event.node_name, AssistantNodeName.ROOT)
            self.assertEqual(event.node_run_id, "integration_run_1")
            self.assertEqual(event.node_path, node_path)

    def test_concurrent_dispatchers(self):
        """Test multiple dispatchers can coexist without interference."""
        dispatched_events_1 = []
        dispatched_events_2 = []

        def writer_1(event):
            dispatched_events_1.append(event)

        def writer_2(event):
            dispatched_events_2.append(event)

        path_1 = (NodePath(name=AssistantGraphName.ASSISTANT), NodePath(name=AssistantNodeName.ROOT))
        path_2 = (NodePath(name=AssistantGraphName.ASSISTANT), NodePath(name=AssistantNodeName.TRENDS_GENERATOR))

        dispatcher_1 = AssistantDispatcher(
            writer=writer_1, node_path=path_1, node_name=AssistantNodeName.ROOT, node_run_id="run_1"
        )

        dispatcher_2 = AssistantDispatcher(
            writer=writer_2, node_path=path_2, node_name=AssistantNodeName.TRENDS_GENERATOR, node_run_id="run_2"
        )

        # Dispatch from both
        dispatcher_1.message(AssistantMessage(content="From dispatcher 1"))
        dispatcher_2.message(AssistantMessage(content="From dispatcher 2"))
        dispatcher_1.update("Update from dispatcher 1")
        dispatcher_2.update("Update from dispatcher 2")

        # Verify each dispatcher wrote to its own writer
        self.assertEqual(len(dispatched_events_1), 2)
        self.assertEqual(len(dispatched_events_2), 2)

        # Verify events went to correct writers
        assert isinstance(dispatched_events_1[0].action, MessageAction)
        assert isinstance(dispatched_events_1[0].action.message, AssistantMessage)
        self.assertEqual(dispatched_events_1[0].action.message.content, "From dispatcher 1")
        assert isinstance(dispatched_events_2[0].action, MessageAction)
        assert isinstance(dispatched_events_2[0].action.message, AssistantMessage)
        self.assertEqual(dispatched_events_2[0].action.message.content, "From dispatcher 2")

        # Verify node names are correct
        self.assertEqual(dispatched_events_1[0].node_name, AssistantNodeName.ROOT)
        self.assertEqual(dispatched_events_2[0].node_name, AssistantNodeName.TRENDS_GENERATOR)