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.

11.4 KB
Raw Blame
import pytest
from posthog.test.base import NonAtomicBaseTest
from unittest.mock import AsyncMock, MagicMock, patch

from langchain_core.runnables import RunnableConfig
from parameterized import parameterized

from posthog.event_usage import EventSource
from posthog.models import Team, User

from products.posthog_ai.backend.models.assistant import Conversation

from ee.hogai.tool_errors import MaxToolRetryableError
from ee.hogai.tools.read_taxonomy.core import (
    DYNAMIC_EVENT_PROPERTIES_HINT,
    DYNAMIC_PERSON_PROPERTIES_HINT,
    ReadEntityProperties,
    ReadEventProperties,
    ReadEvents,
    execute_taxonomy_query,
)
from ee.hogai.tools.read_taxonomy.tool import ReadTaxonomyTool
from ee.hogai.utils.types import AssistantState
from ee.hogai.utils.types.base import NodePath
from ee.models.event_definition import EnterpriseEventDefinition


class TestReadTaxonomyTool(NonAtomicBaseTest):
    CLASS_DATA_LEVEL_SETUP = False

    def setUp(self):
        super().setUp()
        self.tool_call_id = "test_tool_call_id"
        self.conversation = Conversation.objects.create(user=self.user, team=self.team)

    @patch("ee.hogai.tools.read_taxonomy.tool.AssistantContextManager")
    async def test_tool_has_correct_name(self, mock_context_manager_class):
        mock_context_manager = MagicMock()
        mock_context_manager.get_group_names = AsyncMock(return_value=["organization", "project"])
        mock_context_manager_class.return_value = mock_context_manager

        config = RunnableConfig(configurable={"thread_id": str(self.conversation.id)})
        tool = await ReadTaxonomyTool.create_tool_class(
            team=self.team,
            user=self.user,
            state=AssistantState(messages=[]),
            config=config,
            node_path=(NodePath(name="test_node", tool_call_id=self.tool_call_id, message_id="test"),),
        )

        self.assertEqual(tool.name, "read_taxonomy")

    @patch("ee.hogai.tools.read_taxonomy.tool.AssistantContextManager")
    async def test_create_tool_class_includes_groups_in_schema(self, mock_context_manager_class):
        mock_context_manager = MagicMock()
        mock_context_manager.get_group_names = AsyncMock(return_value=["organization", "project"])
        mock_context_manager_class.return_value = mock_context_manager

        config = RunnableConfig(configurable={"thread_id": str(self.conversation.id)})
        tool = await ReadTaxonomyTool.create_tool_class(
            team=self.team,
            user=self.user,
            state=AssistantState(messages=[]),
            config=config,
            node_path=(NodePath(name="test_node", tool_call_id=self.tool_call_id, message_id="test"),),
        )

        assert tool.args_schema is not None and isinstance(tool.args_schema, type)
        schema = tool.args_schema.model_json_schema()
        entity_properties_schema = schema["$defs"]["ReadEntityProperties"]["properties"]["entity"]

        self.assertIn("organization", entity_properties_schema["enum"])
        self.assertIn("project", entity_properties_schema["enum"])
        self.assertIn("person", entity_properties_schema["enum"])
        self.assertIn("session", entity_properties_schema["enum"])

    @parameterized.expand(
        [
            ("wrong_field_name", {"kind": "event_properties", "event": "$pageview"}, "event_name"),
            ("wrong_discriminator_value", {"kind": "ReadEvents"}, "ReadEvents"),
            (
                "missing_required_field",
                {"kind": "event_property_values", "event_name": "$pageview"},
                "property_name",
            ),
        ]
    )
    @patch("ee.hogai.tools.read_taxonomy.tool.AssistantContextManager")
    async def test_run_impl_wraps_validation_error_in_retryable_error(
        self, _name, query, expected_match, mock_context_manager_class
    ):
        mock_context_manager = MagicMock()
        mock_context_manager.get_group_names = AsyncMock(return_value=[])
        mock_context_manager_class.return_value = mock_context_manager

        config = RunnableConfig(configurable={"thread_id": str(self.conversation.id)})
        tool = await ReadTaxonomyTool.create_tool_class(
            team=self.team,
            user=self.user,
            state=AssistantState(messages=[]),
            config=config,
            node_path=(NodePath(name="test_node", tool_call_id=self.tool_call_id, message_id="test"),),
        )

        with pytest.raises(MaxToolRetryableError, match=expected_match):
            tool._run_impl(query=query)

    @patch("ee.hogai.tools.read_taxonomy.core.TaxonomyAgentToolkit")
    @patch("ee.hogai.tools.read_taxonomy.core.format_events_yaml")
    def test_execute_taxonomy_query_read_events(self, mock_format_events, mock_toolkit_class):
        mock_format_events.return_value = "events:\n  - $pageview\n  - $autocapture"

        result = execute_taxonomy_query(ReadEvents(), mock_toolkit_class.return_value, self.team, self.user)

        self.assertIn("events:", result)
        mock_format_events.assert_called_once_with(
            [], self.team, self.user, limit=500, offset=0, event_source=EventSource.POSTHOG_AI
        )

    @parameterized.expand([("singular", "person"), ("plural", "persons")])
    @patch("ee.hogai.tools.read_taxonomy.core.TaxonomyAgentToolkit")
    def test_person_entity_properties_include_dynamic_hint(self, _name, entity, mock_toolkit_class):
        mock_toolkit = mock_toolkit_class.return_value
        mock_toolkit.retrieve_entity_properties.return_value = "- email\n- name"

        result = execute_taxonomy_query(ReadEntityProperties(entity=entity), mock_toolkit, self.team, self.user)

        self.assertIn(DYNAMIC_PERSON_PROPERTIES_HINT, result)
        self.assertIn("$survey_dismissed", result)
        self.assertIn("$feature_enrollment", result)
        self.assertIn("$product_tour_dismissed", result)
        self.assertIn("$survey_responded/{survey_id}/{iteration}", result)

    @patch("ee.hogai.tools.read_taxonomy.core.TaxonomyAgentToolkit")
    def test_non_person_entity_properties_exclude_dynamic_hint(self, mock_toolkit_class):
        mock_toolkit = mock_toolkit_class.return_value
        mock_toolkit.retrieve_entity_properties.return_value = "- $start_timestamp"

        result = execute_taxonomy_query(ReadEntityProperties(entity="session"), mock_toolkit, self.team, self.user)

        self.assertNotIn(DYNAMIC_PERSON_PROPERTIES_HINT, result)

    @patch("ee.hogai.tools.read_taxonomy.core.TaxonomyAgentToolkit")
    def test_event_properties_include_dynamic_hint(self, mock_toolkit_class):
        mock_toolkit = mock_toolkit_class.return_value
        mock_toolkit.retrieve_event_or_action_properties.return_value = "- $browser\n- $os"

        result = execute_taxonomy_query(ReadEventProperties(event_name="$pageview"), mock_toolkit, self.team, self.user)

        self.assertIn(DYNAMIC_EVENT_PROPERTIES_HINT, result)
        self.assertIn("$feature/{flag_key}", result)

    @parameterized.expand(
        [
            ("with_description", "Fired when a user retakes a quiz", True),
            ("without_description", None, False),
        ]
    )
    @patch("ee.hogai.tools.read_taxonomy.core.TaxonomyAgentToolkit")
    def test_event_properties_surface_stored_event_description(
        self, _name, stored_description, expect_prefix, mock_toolkit_class
    ):
        # Guards the single-event path surfacing a custom event's own description: without it the
        # agent only sees the property list and wrongly concludes no description exists.
        mock_toolkit = mock_toolkit_class.return_value
        mock_toolkit.retrieve_event_or_action_properties.return_value = "- mixer_session_id\n- is_autoplay"
        if stored_description is not None:
            EnterpriseEventDefinition.objects.create(
                team=self.team, name="quiz_retaken", description=stored_description
            )

        result = execute_taxonomy_query(
            ReadEventProperties(event_name="quiz_retaken"), mock_toolkit, self.team, self.user
        )

        if expect_prefix:
            self.assertIn(f"Description of `quiz_retaken`: {stored_description}", result)
        else:
            self.assertNotIn("Description of `quiz_retaken`", result)
        self.assertIn("mixer_session_id", result)

    @parameterized.expand(
        [
            ("custom_event", "quiz_retaken", "Ada", "Lovelace", "Ada Lovelace ([email protected])"),
            ("core_event", "$pageview", "Ada", "Lovelace", "Ada Lovelace ([email protected])"),
            ("owner_without_name", "quiz_retaken", "", "", "[email protected]"),
            (
                "name_with_line_break",
                "quiz_retaken",
                "Ada\n# SYSTEM:",
                "Lovelace",
                "Ada # SYSTEM: Lovelace ([email protected])",
            ),
        ]
    )
    @patch("ee.hogai.tools.read_taxonomy.core.TaxonomyAgentToolkit")
    def test_event_properties_surface_event_owner(
        self, _name, event_name, first_name, last_name, expected_owner, mock_toolkit_class
    ):
        mock_toolkit = mock_toolkit_class.return_value
        mock_toolkit.retrieve_event_or_action_properties.return_value = "- mixer_session_id"
        owner = User.objects.create_and_join(
            self.organization, "[email protected]", None, first_name=first_name, last_name=last_name
        )
        EnterpriseEventDefinition.objects.create(team=self.team, name=event_name, owner=owner)

        result = execute_taxonomy_query(ReadEventProperties(event_name=event_name), mock_toolkit, self.team, self.user)

        self.assertIn(f"Owner of `{event_name}`: {expected_owner}\n", result)
        self.assertIn("mixer_session_id", result)

    @patch("ee.hogai.tools.read_taxonomy.core.TaxonomyAgentToolkit")
    def test_event_properties_omit_owner_when_unset(self, mock_toolkit_class):
        mock_toolkit = mock_toolkit_class.return_value
        mock_toolkit.retrieve_event_or_action_properties.return_value = "- mixer_session_id"
        EnterpriseEventDefinition.objects.create(team=self.team, name="quiz_retaken", description="Retook a quiz")

        result = execute_taxonomy_query(
            ReadEventProperties(event_name="quiz_retaken"), mock_toolkit, self.team, self.user
        )

        self.assertNotIn("Owner of", result)
        self.assertIn("Description of `quiz_retaken`: Retook a quiz", result)

    @parameterized.expand([("other_environment_same_project", True), ("other_project", False)])
    @patch("ee.hogai.tools.read_taxonomy.core.TaxonomyAgentToolkit")
    def test_event_properties_owner_is_scoped_to_the_project(self, _name, same_project, mock_toolkit_class):
        mock_toolkit = mock_toolkit_class.return_value
        mock_toolkit.retrieve_event_or_action_properties.return_value = "- mixer_session_id"
        owner = User.objects.create_and_join(self.organization, "[email protected]", None, first_name="Ada")
        # Without a project, the manager creates a new one for the team.
        project_kwargs = {"project_id": self.team.project_id} if same_project else {}
        other_team = Team.objects.create(organization=self.organization, name="other", **project_kwargs)
        EnterpriseEventDefinition.objects.create(
            team=other_team, project_id=other_team.project_id, name="quiz_retaken", owner=owner
        )

        result = execute_taxonomy_query(
            ReadEventProperties(event_name="quiz_retaken"), mock_toolkit, self.team, self.user
        )

        if same_project:
            self.assertIn("Owner of `quiz_retaken`: Ada ([email protected])\n", result)
        else:
            self.assertNotIn("Owner of", result)