: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.
Python ab-testingai-analyticsanalyticscdpdata-warehouseexperimentsfeature-flagsjavascriptproduct-analyticspythonreactsession-replaysurveystypescriptweb-analytics
from posthog.test.base import BaseTest
from langchain_core.runnables import RunnableConfig
from products.posthog_ai.backend.models.assistant import Conversation
from ee.hogai.core.base import BaseAssistantGraph
from ee.hogai.core.context import get_node_path
from ee.hogai.core.node import AssistantNode
from ee.hogai.utils.types import AssistantNodeName, AssistantState, PartialAssistantState
from ee.hogai.utils.types.base import AssistantGraphName, NodePath
class TestNodePath(BaseTest):
"""
Tests for node_path functionality across sync/async methods and graph compositions.
"""
async def test_graph_to_async_node_has_two_elements(self):
"""Graph -> Node (async) should have path: [graph, node]"""
captured_path = None
class TestNode(AssistantNode):
async def arun(self, state, config):
nonlocal captured_path
captured_path = get_node_path()
return None
class TestGraph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.ASSISTANT
def setup(self):
node = TestNode(self._team, self._user)
self.add_node(AssistantNodeName.ROOT, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.ROOT)
self.add_edge(AssistantNodeName.ROOT, AssistantNodeName.END)
return self
graph = TestGraph(self.team, self.user)
compiled = graph.setup().compile(checkpointer=False)
conversation = await Conversation.objects.acreate(team=self.team, user=self.user)
await compiled.ainvoke(AssistantState(messages=[]), {"configurable": {"thread_id": conversation.id}})
assert captured_path is not None
self.assertEqual(len(captured_path), 2)
self.assertEqual(captured_path[0].name, AssistantGraphName.ASSISTANT.value)
# Node name is determined at init time, so it's the class name
self.assertEqual(captured_path[1].name, AssistantNodeName.ROOT)
async def test_graph_to_sync_node_has_two_elements(self):
"""Graph -> Node (sync) should have path: [graph, node]"""
captured_path = None
class TestNode(AssistantNode):
def run(self, state, config):
nonlocal captured_path
captured_path = get_node_path()
return None
class TestGraph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.ASSISTANT
def setup(self):
node = TestNode(self._team, self._user)
self.add_node(AssistantNodeName.ROOT, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.ROOT)
self.add_edge(AssistantNodeName.ROOT, AssistantNodeName.END)
return self
graph = TestGraph(self.team, self.user)
compiled = graph.setup().compile(checkpointer=False)
conversation = await Conversation.objects.acreate(team=self.team, user=self.user)
await compiled.ainvoke(AssistantState(messages=[]), {"configurable": {"thread_id": conversation.id}})
assert captured_path is not None
self.assertEqual(len(captured_path), 2)
self.assertEqual(captured_path[0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_path[1].name, AssistantNodeName.ROOT)
async def test_graph_to_node_to_async_node_has_three_elements(self):
"""Graph -> Node -> Node (async) should have path: [graph, node, node]"""
captured_paths = []
class SecondNode(AssistantNode):
async def arun(self, state, config):
nonlocal captured_paths
captured_paths.append(get_node_path())
return None
class FirstNode(AssistantNode):
async def arun(self, state, config):
nonlocal captured_paths
captured_paths.append(get_node_path())
# Call second node
second_node = SecondNode(self._team, self._user)
await second_node(state, config)
return None
class TestGraph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.ASSISTANT
def setup(self):
node = FirstNode(self._team, self._user)
self.add_node(AssistantNodeName.ROOT, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.ROOT)
self.add_edge(AssistantNodeName.ROOT, AssistantNodeName.END)
return self
graph = TestGraph(self.team, self.user)
compiled = graph.setup().compile(checkpointer=False)
conversation = await Conversation.objects.acreate(team=self.team, user=self.user)
await compiled.ainvoke(AssistantState(messages=[]), {"configurable": {"thread_id": conversation.id}})
# First node: [graph, node]
assert captured_paths[0] is not None
self.assertEqual(len(captured_paths[0]), 2)
self.assertEqual(captured_paths[0][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_paths[0][1].name, AssistantNodeName.ROOT)
# Second node: [graph, node, node]
assert captured_paths[1] is not None
self.assertEqual(len(captured_paths[1]), 3)
self.assertEqual(captured_paths[1][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_paths[1][1].name, AssistantNodeName.ROOT)
self.assertEqual(captured_paths[1][2].name, AssistantNodeName.ROOT)
async def test_graph_to_node_to_sync_node_has_three_elements(self):
"""Graph -> Node -> Node (sync) - calling .run() directly doesn't extend path"""
captured_paths = []
class SecondNode(AssistantNode):
def run(self, state, config):
nonlocal captured_paths
captured_paths.append(get_node_path())
return None
class FirstNode(AssistantNode):
def run(self, state, config):
nonlocal captured_paths
captured_paths.append(get_node_path())
# Call second node - note: calling run() directly bypasses context setting,
# so the second node won't have the proper path. This tests that direct .run()
# calls don't propagate context properly.
second_node = SecondNode(self._team, self._user)
second_node.run(state, config)
return None
class TestGraph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.ASSISTANT
def setup(self):
node = FirstNode(self._team, self._user)
self.add_node(AssistantNodeName.ROOT, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.ROOT)
self.add_edge(AssistantNodeName.ROOT, AssistantNodeName.END)
return self
graph = TestGraph(self.team, self.user)
compiled = graph.setup().compile(checkpointer=False)
conversation = await Conversation.objects.acreate(team=self.team, user=self.user)
await compiled.ainvoke(AssistantState(messages=[]), {"configurable": {"thread_id": conversation.id}})
# First node: [graph, node]
assert captured_paths[0] is not None
self.assertEqual(len(captured_paths[0]), 2)
self.assertEqual(captured_paths[0][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_paths[0][1].name, AssistantNodeName.ROOT)
# Second node: [graph, node] - initialized within FirstNode's context, so gets same path
assert captured_paths[1] is not None
self.assertEqual(len(captured_paths[1]), 2)
self.assertEqual(captured_paths[1][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(
captured_paths[1][1].name, AssistantNodeName.ROOT
) # Same as first because initialized in same context
async def test_graph_to_node_to_graph_to_node_has_four_elements(self):
"""Graph -> Node -> Graph -> Node should have path: [graph, node, graph, node]"""
captured_paths = []
class InnerNode(AssistantNode):
async def arun(self, state, config):
nonlocal captured_paths
captured_paths.append(get_node_path())
return None
class InnerGraph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.INSIGHTS
def setup(self):
node = InnerNode(self._team, self._user)
self.add_node(AssistantNodeName.TRENDS_GENERATOR, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.TRENDS_GENERATOR)
self.add_edge(AssistantNodeName.TRENDS_GENERATOR, AssistantNodeName.END)
return self
class OuterNode(AssistantNode):
async def arun(self, state, config):
nonlocal captured_paths
captured_paths.append(get_node_path())
# Call inner graph
inner_graph = InnerGraph(self._team, self._user)
compiled_inner = inner_graph.setup().compile(checkpointer=False)
await compiled_inner.ainvoke(state, config)
return None
class OuterGraph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.ASSISTANT
def setup(self):
node = OuterNode(self._team, self._user)
self.add_node(AssistantNodeName.ROOT, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.ROOT)
self.add_edge(AssistantNodeName.ROOT, AssistantNodeName.END)
return self
outer_graph = OuterGraph(self.team, self.user)
compiled = outer_graph.setup().compile(checkpointer=False)
conversation = await Conversation.objects.acreate(team=self.team, user=self.user)
await compiled.ainvoke(AssistantState(messages=[]), {"configurable": {"thread_id": conversation.id}})
# Outer node: [graph, node]
assert captured_paths[0] is not None
self.assertEqual(len(captured_paths[0]), 2)
self.assertEqual(captured_paths[0][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_paths[0][1].name, AssistantNodeName.ROOT)
# Inner node: [graph, node, graph, node]
assert captured_paths[1] is not None
self.assertEqual(len(captured_paths[1]), 4)
self.assertEqual(captured_paths[1][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_paths[1][1].name, AssistantNodeName.ROOT)
self.assertEqual(captured_paths[1][2].name, AssistantGraphName.INSIGHTS.value)
self.assertEqual(captured_paths[1][3].name, AssistantNodeName.TRENDS_GENERATOR)
async def test_graph_to_graph_to_node_has_three_elements(self):
"""Graph -> Graph -> Node should have path: [graph, graph, node]"""
captured_path = None
class InnerNode(AssistantNode):
async def arun(self, state, config):
nonlocal captured_path
captured_path = get_node_path()
return None
class InnerGraph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.INSIGHTS
def setup(self):
node = InnerNode(self._team, self._user)
self.add_node(AssistantNodeName.TRENDS_GENERATOR, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.TRENDS_GENERATOR)
self.add_edge(AssistantNodeName.TRENDS_GENERATOR, AssistantNodeName.END)
return self
class OuterGraph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.ASSISTANT
async def invoke_inner_graph(self, state, config):
inner_graph = InnerGraph(self._team, self._user)
compiled_inner = inner_graph.setup().compile(checkpointer=False)
await compiled_inner.ainvoke(state, config)
outer_graph = OuterGraph(self.team, self.user)
conversation = await Conversation.objects.acreate(team=self.team, user=self.user)
await outer_graph.invoke_inner_graph(
AssistantState(messages=[]), RunnableConfig(configurable={"thread_id": conversation.id})
)
# Inner node: [graph, node] - outer graph context is not propagated when calling graph methods directly
assert captured_path is not None
self.assertEqual(len(captured_path), 2)
self.assertEqual(captured_path[0].name, AssistantGraphName.INSIGHTS.value)
self.assertEqual(captured_path[1].name, AssistantNodeName.TRENDS_GENERATOR)
async def test_node_path_preserved_across_async_and_sync_methods(self):
"""Test that calling .run() directly doesn't extend path"""
captured_paths = []
class SyncNode(AssistantNode):
def run(self, state, config):
nonlocal captured_paths
captured_paths.append(("sync", get_node_path()))
return None
class AsyncNode(AssistantNode):
async def arun(self, state, config):
nonlocal captured_paths
captured_paths.append(("async", get_node_path()))
# Call sync node - calling .run() directly bypasses context setting
sync_node = SyncNode(self._team, self._user)
sync_node.run(state, config)
return None
class TestGraph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.ASSISTANT
def setup(self):
node = AsyncNode(self._team, self._user)
self.add_node(AssistantNodeName.ROOT, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.ROOT)
self.add_edge(AssistantNodeName.ROOT, AssistantNodeName.END)
return self
graph = TestGraph(self.team, self.user)
compiled = graph.setup().compile(checkpointer=False)
conversation = await Conversation.objects.acreate(team=self.team, user=self.user)
await compiled.ainvoke(AssistantState(messages=[]), {"configurable": {"thread_id": conversation.id}})
# Async node: [graph, node]
self.assertEqual(captured_paths[0][0], "async")
assert captured_paths[0][1] is not None
self.assertEqual(len(captured_paths[0][1]), 2)
self.assertEqual(captured_paths[0][1][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_paths[0][1][1].name, AssistantNodeName.ROOT)
# Sync node: [graph, node] - initialized within AsyncNode's context, so gets same path
self.assertEqual(captured_paths[1][0], "sync")
assert captured_paths[1][1] is not None
self.assertEqual(len(captured_paths[1][1]), 2)
self.assertEqual(captured_paths[1][1][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(
captured_paths[1][1][1].name, AssistantNodeName.ROOT
) # Same as async because initialized in same context
def test_node_path_with_explicit_node_path_parameter(self):
"""Test that explicitly passing node_path overrides default behavior"""
custom_path = (NodePath(name="custom_graph"), NodePath(name="custom_node"))
class TestNode(AssistantNode):
def run(self, state, config):
return None
node = TestNode(self.team, self.user, node_path=custom_path)
self.assertEqual(len(node._node_path), 2)
self.assertEqual(node._node_path[0].name, "custom_graph")
self.assertEqual(node._node_path[1].name, "custom_node")
async def test_multiple_nested_graphs(self):
"""Test deeply nested graph composition: Graph -> Node -> Graph -> Node -> Graph -> Node"""
captured_paths = []
class Level3Node(AssistantNode):
async def arun(self, state, config):
nonlocal captured_paths
captured_paths.append(("level3", get_node_path()))
return None
class Level3Graph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.TAXONOMY
def setup(self):
node = Level3Node(self._team, self._user)
self.add_node(AssistantNodeName.FUNNEL_GENERATOR, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.FUNNEL_GENERATOR)
self.add_edge(AssistantNodeName.FUNNEL_GENERATOR, AssistantNodeName.END)
return self
class Level2Node(AssistantNode):
async def arun(self, state, config):
nonlocal captured_paths
captured_paths.append(("level2", get_node_path()))
# Call level 3 graph
level3_graph = Level3Graph(self._team, self._user)
compiled = level3_graph.setup().compile(checkpointer=False)
await compiled.ainvoke(state, config)
return None
class Level2Graph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.INSIGHTS
def setup(self):
node = Level2Node(self._team, self._user)
self.add_node(AssistantNodeName.TRENDS_GENERATOR, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.TRENDS_GENERATOR)
self.add_edge(AssistantNodeName.TRENDS_GENERATOR, AssistantNodeName.END)
return self
class Level1Node(AssistantNode):
async def arun(self, state, config):
nonlocal captured_paths
captured_paths.append(("level1", get_node_path()))
# Call level 2 graph
level2_graph = Level2Graph(self._team, self._user)
compiled = level2_graph.setup().compile(checkpointer=False)
await compiled.ainvoke(state, config)
return None
class Level1Graph(BaseAssistantGraph[AssistantState, PartialAssistantState]):
@property
def state_type(self) -> type[AssistantState]:
return AssistantState
@property
def graph_name(self) -> AssistantGraphName:
return AssistantGraphName.ASSISTANT
def setup(self):
node = Level1Node(self._team, self._user)
self.add_node(AssistantNodeName.ROOT, node)
self.add_edge(AssistantNodeName.START, AssistantNodeName.ROOT)
self.add_edge(AssistantNodeName.ROOT, AssistantNodeName.END)
return self
level1_graph = Level1Graph(self.team, self.user)
compiled = level1_graph.setup().compile(checkpointer=False)
conversation = await Conversation.objects.acreate(team=self.team, user=self.user)
await compiled.ainvoke(AssistantState(messages=[]), {"configurable": {"thread_id": conversation.id}})
# Level 1: [graph, node]
assert captured_paths[0][1] is not None
self.assertEqual(len(captured_paths[0][1]), 2)
self.assertEqual(captured_paths[0][1][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_paths[0][1][1].name, AssistantNodeName.ROOT)
# Level 2: [graph, node, graph, node]
assert captured_paths[1][1] is not None
self.assertEqual(len(captured_paths[1][1]), 4)
self.assertEqual(captured_paths[1][1][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_paths[1][1][1].name, AssistantNodeName.ROOT)
self.assertEqual(captured_paths[1][1][2].name, AssistantGraphName.INSIGHTS.value)
self.assertEqual(captured_paths[1][1][3].name, AssistantNodeName.TRENDS_GENERATOR)
# Level 3: [graph, node, graph, node, graph, node]
assert captured_paths[2][1] is not None
self.assertEqual(len(captured_paths[2][1]), 6)
self.assertEqual(captured_paths[2][1][0].name, AssistantGraphName.ASSISTANT.value)
self.assertEqual(captured_paths[2][1][1].name, AssistantNodeName.ROOT)
self.assertEqual(captured_paths[2][1][2].name, AssistantGraphName.INSIGHTS.value)
self.assertEqual(captured_paths[2][1][3].name, AssistantNodeName.TRENDS_GENERATOR)
self.assertEqual(captured_paths[2][1][4].name, AssistantGraphName.TAXONOMY.value)
self.assertEqual(captured_paths[2][1][5].name, AssistantNodeName.FUNNEL_GENERATOR)