: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 uuid import uuid4
from posthog.test.base import BaseTest
from asgiref.sync import async_to_sync
from langchain_core.runnables import RunnableConfig
from parameterized import parameterized
from posthog.schema import (
ArtifactContentType,
ArtifactMessage,
ArtifactSource,
AssistantLifecycleQuery,
AssistantMessage,
AssistantTrendsQuery,
DateRange,
EventPropertyFilter,
EventsNode,
FunnelsQuery,
HumanMessage,
NotebookArtifactContent,
RetentionFilter,
RetentionQuery,
TrendsQuery,
VisualizationArtifactContent,
VisualizationMessage,
)
from products.posthog_ai.backend.models.assistant import AgentArtifact, Conversation
from products.product_analytics.backend.facade.models import Insight
from ee.hogai.artifacts.manager import ArtifactManager
from ee.hogai.artifacts.types import StoredNotebookArtifactContent
from ee.hogai.utils.types.base import ArtifactRefMessage
class TestArtifactManagerCreateMessage(BaseTest):
def setUp(self):
super().setUp()
self.manager = ArtifactManager(team=self.team, user=self.user)
def test_creates_artifact_message_with_defaults(self):
artifact_id = "abc123"
message = self.manager.create_message(artifact_id)
self.assertEqual(message.artifact_id, artifact_id)
self.assertEqual(message.source, ArtifactSource.ARTIFACT)
self.assertEqual(message.content_type, ArtifactContentType.VISUALIZATION)
self.assertIsNotNone(message.id)
class TestArtifactManagerCreate(BaseTest):
def setUp(self):
super().setUp()
self.conversation = Conversation.objects.create(user=self.user, team=self.team)
async def test_creates_artifact_without_config_raises(self):
manager = ArtifactManager(team=self.team, user=self.user, config=None)
content = VisualizationArtifactContent(
query=AssistantTrendsQuery(series=[]),
name="Test",
)
with self.assertRaises(ValueError) as ctx:
await manager.acreate(content, "Test Artifact")
self.assertIn("Config is required", str(ctx.exception))
async def test_creates_artifact_persists_to_database(self):
config = RunnableConfig(configurable={"thread_id": str(self.conversation.id)})
manager = ArtifactManager(team=self.team, user=self.user, config=config)
content = VisualizationArtifactContent(
query=AssistantTrendsQuery(series=[]),
name="Chart Name",
description="Chart description",
)
artifact = await manager.acreate(content, "Test Artifact")
self.assertIsNotNone(artifact.id)
self.assertEqual(artifact.name, "Test Artifact")
self.assertEqual(artifact.type, AgentArtifact.Type.VISUALIZATION)
self.assertEqual(artifact.team_id, self.team.id)
self.assertEqual(artifact.conversation_id, self.conversation.id)
self.assertEqual(artifact.data["name"], "Chart Name")
async def test_creates_artifact_truncates_long_name(self):
config = RunnableConfig(configurable={"thread_id": str(self.conversation.id)})
manager = ArtifactManager(team=self.team, user=self.user, config=config)
content = VisualizationArtifactContent(query=AssistantTrendsQuery(series=[]))
long_name = "A" * 500
artifact = await manager.acreate(content, long_name)
self.assertEqual(len(artifact.name), 400)
def test_creates_notebook_artifact_with_correct_type(self):
config = RunnableConfig(configurable={"thread_id": str(self.conversation.id)})
manager = ArtifactManager(team=self.team, user=self.user, config=config)
content = StoredNotebookArtifactContent(blocks=[])
artifact = async_to_sync(manager.acreate)(content, "Test Notebook")
self.assertIsNotNone(artifact.id)
self.assertEqual(artifact.name, "Test Notebook")
self.assertEqual(artifact.type, AgentArtifact.Type.NOTEBOOK)
self.assertEqual(artifact.data["blocks"], [])
class TestArtifactManagerGetContentByShortId(BaseTest):
def setUp(self):
super().setUp()
self.conversation = Conversation.objects.create(user=self.user, team=self.team)
self.manager = ArtifactManager(team=self.team, user=self.user)
async def test_retrieves_content_by_short_id(self):
artifact = await AgentArtifact.objects.acreate(
name="Test Artifact",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Test"},
conversation=self.conversation,
team=self.team,
)
content = await self.manager.aget(artifact.short_id, VisualizationArtifactContent)
self.assertEqual(content.name, "Test")
async def test_raises_when_artifact_not_found(self):
with self.assertRaises(AgentArtifact.DoesNotExist):
await self.manager.aget("xxxx")
def test_retrieves_notebook_content_by_short_id(self):
artifact = AgentArtifact.objects.create(
name="Test Notebook",
type=AgentArtifact.Type.NOTEBOOK,
data={"blocks": [{"type": "markdown", "content": "Hello"}]},
conversation=self.conversation,
team=self.team,
)
content = async_to_sync(self.manager.aget)(artifact.short_id, NotebookArtifactContent)
self.assertIsInstance(content, NotebookArtifactContent)
self.assertEqual(len(content.blocks), 1)
def test_retrieves_content_with_expected_type(self):
artifact = AgentArtifact.objects.create(
name="Test Artifact",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Test"},
conversation=self.conversation,
team=self.team,
)
content = async_to_sync(self.manager.aget)(artifact.short_id, VisualizationArtifactContent)
self.assertIsInstance(content, VisualizationArtifactContent)
self.assertEqual(content.name, "Test")
def test_raises_type_error_when_expected_type_mismatches(self):
artifact = AgentArtifact.objects.create(
name="Test Artifact",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Test"},
conversation=self.conversation,
team=self.team,
)
with self.assertRaises(TypeError) as ctx:
async_to_sync(self.manager.aget)(artifact.short_id, NotebookArtifactContent)
self.assertIn("Expected content type=NotebookArtifactContent", str(ctx.exception))
self.assertIn("got content type=VisualizationArtifactContent", str(ctx.exception))
class TestArtifactManagerGetEnrichedMessage(BaseTest):
def setUp(self):
super().setUp()
self.conversation = Conversation.objects.create(user=self.user, team=self.team)
self.manager = ArtifactManager(team=self.team, user=self.user)
async def test_enriches_artifact_source_message(self):
artifact = await AgentArtifact.objects.acreate(
name="Enriched Artifact",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Enriched"},
conversation=self.conversation,
team=self.team,
)
message = ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=artifact.short_id,
source=ArtifactSource.ARTIFACT,
)
enriched = await self.manager.aenrich_message(message)
self.assertIsNotNone(enriched)
assert enriched is not None
assert isinstance(enriched.content, VisualizationArtifactContent)
self.assertEqual(enriched.content.name, "Enriched")
async def test_enriches_state_source_message(self):
viz_msg_id = str(uuid4())
viz_message = VisualizationMessage(
id=viz_msg_id,
query="test query",
answer=TrendsQuery(series=[]),
plan="test plan",
)
artifact_message = ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=viz_msg_id,
source=ArtifactSource.STATE,
)
enriched = await self.manager.aenrich_message(artifact_message, state_messages=[viz_message, artifact_message])
self.assertIsNotNone(enriched)
assert enriched is not None
assert isinstance(enriched.content, VisualizationArtifactContent)
self.assertEqual(enriched.content.name, "Insight")
self.assertEqual(enriched.content.plan, "test plan")
async def test_state_source_without_state_messages_raises(self):
message = ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id="ref",
source=ArtifactSource.STATE,
)
with self.assertRaises(ValueError) as ctx:
await self.manager.aenrich_message(message, state_messages=None)
self.assertIn("state_messages required", str(ctx.exception))
async def test_returns_none_when_content_not_found(self):
message = ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id="nonexistent",
source=ArtifactSource.ARTIFACT,
)
enriched = await self.manager.aenrich_message(message)
self.assertIsNone(enriched)
class TestArtifactManagerGetContentsByMessageId(BaseTest):
def setUp(self):
super().setUp()
self.conversation = Conversation.objects.create(user=self.user, team=self.team)
self.manager = ArtifactManager(team=self.team, user=self.user)
async def test_fetches_artifact_contents_in_batch(self):
artifact1 = await AgentArtifact.objects.acreate(
name="Artifact 1",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "First"},
conversation=self.conversation,
team=self.team,
)
artifact2 = await AgentArtifact.objects.acreate(
name="Artifact 2",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Second"},
conversation=self.conversation,
team=self.team,
)
msg1_id = str(uuid4())
msg2_id = str(uuid4())
messages = [
ArtifactRefMessage(
id=msg1_id,
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=artifact1.short_id,
source=ArtifactSource.ARTIFACT,
),
ArtifactRefMessage(
id=msg2_id,
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=artifact2.short_id,
source=ArtifactSource.ARTIFACT,
),
]
contents = await self.manager._aget_contents_by_id(messages, aggregate_by="message_id")
self.assertEqual(len(contents), 2)
content1 = contents[msg1_id]
content2 = contents[msg2_id]
assert isinstance(content1, VisualizationArtifactContent)
assert isinstance(content2, VisualizationArtifactContent)
self.assertEqual(content1.name, "First")
self.assertEqual(content2.name, "Second")
async def test_extracts_content_from_state_visualization_messages(self):
viz_id = str(uuid4())
viz_message = VisualizationMessage(
id=viz_id,
query="state query",
answer=TrendsQuery(series=[]),
plan="state plan",
)
artifact_msg_id = str(uuid4())
artifact_message = ArtifactRefMessage(
id=artifact_msg_id,
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=viz_id,
source=ArtifactSource.STATE,
)
messages: list[VisualizationMessage | ArtifactRefMessage] = [
viz_message,
artifact_message,
]
contents = await self.manager._aget_contents_by_id(messages, aggregate_by="message_id")
self.assertEqual(len(contents), 1)
content = contents[artifact_msg_id]
assert isinstance(content, VisualizationArtifactContent)
self.assertEqual(content.name, "Insight")
self.assertEqual(content.plan, "state plan")
@parameterized.expand(
[
(
"funnels_with_label_and_explicit_date",
FunnelsQuery(
series=[
EventsNode(
event="$pageview",
properties=[
EventPropertyFilter(key="$pathname", value=["/"], label=None),
],
),
],
dateRange=DateRange(date_from="-30d", explicitDate=False),
),
FunnelsQuery,
),
(
"trends_with_explicit_date",
TrendsQuery(
series=[EventsNode(event="$pageview")],
dateRange=DateRange(date_from="-7d", explicitDate=False),
),
TrendsQuery,
),
(
"retention_with_explicit_date",
RetentionQuery(
retentionFilter=RetentionFilter(),
dateRange=DateRange(date_from="-14d", explicitDate=False),
),
RetentionQuery,
),
]
)
async def test_extracts_content_from_state_with_non_assistant_query_fields(self, _name, query, expected_type):
viz_id = str(uuid4())
viz_message = VisualizationMessage(
id=viz_id,
query="test query",
answer=query,
plan="test plan",
)
artifact_msg_id = str(uuid4())
artifact_message = ArtifactRefMessage(
id=artifact_msg_id,
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=viz_id,
source=ArtifactSource.STATE,
)
messages: list[VisualizationMessage | ArtifactRefMessage] = [
viz_message,
artifact_message,
]
contents = await self.manager._aget_contents_by_id(messages, aggregate_by="message_id")
self.assertEqual(len(contents), 1)
content = contents[artifact_msg_id]
assert isinstance(content, VisualizationArtifactContent)
assert isinstance(content.query, expected_type)
self.assertEqual(content.name, "Insight")
self.assertEqual(content.plan, "test plan")
class TestArtifactManagerEnrichMessages(BaseTest):
def setUp(self):
super().setUp()
self.conversation = Conversation.objects.create(user=self.user, team=self.team)
self.manager = ArtifactManager(team=self.team, user=self.user)
async def test_converts_artifact_messages_to_visualization_artifact_messages(self):
artifact = await AgentArtifact.objects.acreate(
name="Artifact",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Enriched"},
conversation=self.conversation,
team=self.team,
)
artifact_message = ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=artifact.short_id,
source=ArtifactSource.ARTIFACT,
)
messages = [artifact_message]
enriched = await self.manager.aenrich_messages(messages)
self.assertEqual(len(enriched), 1)
msg = enriched[0]
assert isinstance(msg, ArtifactMessage)
assert isinstance(msg.content, VisualizationArtifactContent)
self.assertEqual(msg.content.name, "Enriched")
async def test_passes_through_non_artifact_messages(self):
assistant_msg = AssistantMessage(id=str(uuid4()), content="Hello")
human_msg = HumanMessage(id=str(uuid4()), content="Hi")
messages: list[AssistantMessage | HumanMessage] = [assistant_msg, human_msg]
enriched = await self.manager.aenrich_messages(messages)
self.assertEqual(len(enriched), 2)
self.assertEqual(enriched[0], assistant_msg)
self.assertEqual(enriched[1], human_msg)
async def test_filters_visualization_messages(self):
viz_message = VisualizationMessage(
id=str(uuid4()),
query="query",
answer=TrendsQuery(series=[]),
plan="plan",
)
assistant_msg = AssistantMessage(id=str(uuid4()), content="Hello")
messages: list[VisualizationMessage | AssistantMessage] = [
viz_message,
assistant_msg,
]
enriched = await self.manager.aenrich_messages(messages)
self.assertEqual(len(enriched), 1)
self.assertEqual(enriched[0], assistant_msg)
async def test_artifacts_only_flag_filters_non_artifact_messages(self):
artifact = await AgentArtifact.objects.acreate(
name="Artifact",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Only"},
conversation=self.conversation,
team=self.team,
)
artifact_message = ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=artifact.short_id,
source=ArtifactSource.ARTIFACT,
)
assistant_msg = AssistantMessage(id=str(uuid4()), content="Hello")
messages: list[ArtifactRefMessage | AssistantMessage] = [
artifact_message,
assistant_msg,
]
enriched = await self.manager.aenrich_messages(messages, artifacts_only=True)
self.assertEqual(len(enriched), 1)
msg = enriched[0]
assert isinstance(msg, ArtifactMessage)
assert isinstance(msg.content, VisualizationArtifactContent)
self.assertEqual(msg.content.name, "Only")
async def test_skips_artifact_messages_without_content(self):
artifact_message = ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id="nonexistent",
source=ArtifactSource.ARTIFACT,
)
messages = [artifact_message]
enriched = await self.manager.aenrich_messages(messages)
self.assertEqual(len(enriched), 0)
async def test_fetches_paths_query_insight(self):
from ee.hogai.artifacts.handlers import VisualizationHandler
insight = await Insight.objects.acreate(
team=self.team,
name="Paths Insight",
description="Test paths insight",
saved=True,
query={
"source": {
"kind": "PathsQuery",
"pathsFilter": {"includeEventTypes": ["$pageview"]},
}
},
)
viz_handler = VisualizationHandler()
results = await viz_handler._from_insights_with_models([insight.short_id], self.team)
self.assertEqual(len(results), 1)
content, _ = results[insight.short_id]
self.assertEqual(content.name, "Paths Insight")
async def test_skips_insight_with_invalid_query(self):
from ee.hogai.artifacts.handlers import VisualizationHandler
insight = await Insight.objects.acreate(
team=self.team,
name="Invalid Insight",
saved=True,
query={
"source": {
"kind": "InvalidQueryType",
"data": "invalid",
}
},
)
viz_handler = VisualizationHandler()
results = await viz_handler._from_insights_with_models([insight.short_id], self.team)
self.assertEqual(len(results), 0)
class TestArtifactManagerGetConversationArtifacts(BaseTest):
def setUp(self):
super().setUp()
self.conversation = Conversation.objects.create(user=self.user, team=self.team)
config = RunnableConfig(configurable={"thread_id": str(self.conversation.id)})
self.manager = ArtifactManager(team=self.team, user=self.user, config=config)
async def test_returns_all_artifacts_when_no_limit(self):
for i in range(5):
await AgentArtifact.objects.acreate(
name=f"Artifact {i}",
type=AgentArtifact.Type.VISUALIZATION,
data={
"query": {"kind": "TrendsQuery", "series": []},
"name": f"Chart {i}",
},
conversation=self.conversation,
team=self.team,
)
artifacts, total_count = await self.manager.aget_conversation_artifacts()
self.assertEqual(len(artifacts), 5)
self.assertEqual(total_count, 5)
async def test_respects_limit(self):
for i in range(5):
await AgentArtifact.objects.acreate(
name=f"Artifact {i}",
type=AgentArtifact.Type.VISUALIZATION,
data={
"query": {"kind": "TrendsQuery", "series": []},
"name": f"Chart {i}",
},
conversation=self.conversation,
team=self.team,
)
artifacts, total_count = await self.manager.aget_conversation_artifacts(limit=2)
self.assertEqual(len(artifacts), 2)
self.assertEqual(total_count, 5)
async def test_respects_offset(self):
for i in range(5):
await AgentArtifact.objects.acreate(
name=f"Artifact {i}",
type=AgentArtifact.Type.VISUALIZATION,
data={
"query": {"kind": "TrendsQuery", "series": []},
"name": f"Chart {i}",
},
conversation=self.conversation,
team=self.team,
)
artifacts, total_count = await self.manager.aget_conversation_artifacts(limit=2, offset=3)
self.assertEqual(len(artifacts), 2)
self.assertEqual(total_count, 5)
async def test_offset_without_limit_returns_remaining(self):
for i in range(5):
await AgentArtifact.objects.acreate(
name=f"Artifact {i}",
type=AgentArtifact.Type.VISUALIZATION,
data={
"query": {"kind": "TrendsQuery", "series": []},
"name": f"Chart {i}",
},
conversation=self.conversation,
team=self.team,
)
artifacts, total_count = await self.manager.aget_conversation_artifacts(offset=3)
self.assertEqual(len(artifacts), 2)
self.assertEqual(total_count, 5)
async def test_returns_empty_for_no_artifacts(self):
artifacts, total_count = await self.manager.aget_conversation_artifacts()
self.assertEqual(len(artifacts), 0)
self.assertEqual(total_count, 0)
async def test_only_returns_artifacts_from_same_conversation(self):
other_conversation = await Conversation.objects.acreate(user=self.user, team=self.team)
await AgentArtifact.objects.acreate(
name="Same Conversation",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Same"},
conversation=self.conversation,
team=self.team,
)
await AgentArtifact.objects.acreate(
name="Other Conversation",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Other"},
conversation=other_conversation,
team=self.team,
)
artifacts, total_count = await self.manager.aget_conversation_artifacts()
self.assertEqual(len(artifacts), 1)
self.assertEqual(total_count, 1)
assert isinstance(artifacts[0].content, VisualizationArtifactContent)
self.assertEqual(artifacts[0].content.name, "Same")
class TestArtifactManagerGetVisualizationWithSource(BaseTest):
def setUp(self):
super().setUp()
self.manager = ArtifactManager(team=self.team, user=self.user)
async def test_retrieves_lifecycle_query_insight(self):
insight = await Insight.objects.acreate(
team=self.team,
name="Lifecycle Insight",
description="Test lifecycle insight",
saved=True,
query={
"source": {
"kind": "LifecycleQuery",
"series": [{"kind": "EventsNode", "name": "$pageview"}],
}
},
)
result = await self.manager.aget_visualization([], insight.short_id)
self.assertIsNotNone(result)
assert result is not None
self.assertEqual(result.source, ArtifactSource.INSIGHT)
assert isinstance(result.content, VisualizationArtifactContent)
self.assertEqual(result.content.name, "Lifecycle Insight")
self.assertEqual(result.content.description, "Test lifecycle insight")
assert isinstance(result.content.query, AssistantLifecycleQuery)
async def test_retrieves_visualizations_in_batch(self):
"""Test that aget_visualizations returns ordered list matching input IDs."""
insight1 = await Insight.objects.acreate(
team=self.team,
name="First Insight",
saved=True,
query={"source": {"kind": "TrendsQuery", "series": []}},
)
insight2 = await Insight.objects.acreate(
team=self.team,
name="Second Insight",
saved=True,
query={"source": {"kind": "TrendsQuery", "series": []}},
)
# Request in specific order
results = await self.manager.aget_visualizations([], [insight2.short_id, insight1.short_id, "nonexistent"])
self.assertEqual(len(results), 3)
# Results should match input order
assert results[0] is not None
assert results[1] is not None
assert results[2] is None # nonexistent
assert isinstance(results[0].content, VisualizationArtifactContent)
assert isinstance(results[1].content, VisualizationArtifactContent)
self.assertEqual(results[0].content.name, "Second Insight")
self.assertEqual(results[1].content.name, "First Insight")
class TestArtifactManagerUpdate(BaseTest):
def setUp(self):
super().setUp()
self.conversation = Conversation.objects.create(user=self.user, team=self.team)
self.manager = ArtifactManager(team=self.team, user=self.user)
async def test_updates_existing_artifact_data(self):
artifact = await AgentArtifact.objects.acreate(
name="Original Artifact",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Original"},
conversation=self.conversation,
team=self.team,
)
new_content = VisualizationArtifactContent(
query=AssistantTrendsQuery(series=[]),
name="Updated Name",
description="Updated description",
)
updated = await self.manager.aupdate(artifact.short_id, new_content)
self.assertEqual(updated.short_id, artifact.short_id)
self.assertEqual(updated.data["name"], "Updated Name")
self.assertEqual(updated.data["description"], "Updated description")
async def test_raises_when_artifact_not_found(self):
new_content = VisualizationArtifactContent(
query=AssistantTrendsQuery(series=[]),
name="Test",
)
with self.assertRaises(ValueError) as ctx:
await self.manager.aupdate("nonexistent", new_content)
self.assertIn("not found", str(ctx.exception))
class TestArtifactManagerGetContentsByArtifactId(BaseTest):
def setUp(self):
super().setUp()
self.conversation = Conversation.objects.create(user=self.user, team=self.team)
self.manager = ArtifactManager(team=self.team, user=self.user)
async def test_aggregate_by_artifact_id_groups_correctly(self):
artifact = await AgentArtifact.objects.acreate(
name="Test Artifact",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Test"},
conversation=self.conversation,
team=self.team,
)
messages = [
ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=artifact.short_id,
source=ArtifactSource.ARTIFACT,
),
]
contents = await self.manager._aget_contents_by_id(messages, aggregate_by="artifact_id")
self.assertEqual(len(contents), 1)
self.assertIn(artifact.short_id, contents)
content = contents[artifact.short_id]
assert isinstance(content, VisualizationArtifactContent)
self.assertEqual(content.name, "Test")
async def test_filter_by_artifact_ids_filters_results(self):
artifact1 = await AgentArtifact.objects.acreate(
name="Artifact 1",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "First"},
conversation=self.conversation,
team=self.team,
)
artifact2 = await AgentArtifact.objects.acreate(
name="Artifact 2",
type=AgentArtifact.Type.VISUALIZATION,
data={"query": {"kind": "TrendsQuery", "series": []}, "name": "Second"},
conversation=self.conversation,
team=self.team,
)
messages = [
ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=artifact1.short_id,
source=ArtifactSource.ARTIFACT,
),
ArtifactRefMessage(
id=str(uuid4()),
content_type=ArtifactContentType.VISUALIZATION,
artifact_id=artifact2.short_id,
source=ArtifactSource.ARTIFACT,
),
]
contents = await self.manager._aget_contents_by_id(
messages,
aggregate_by="artifact_id",
filter_by_artifact_ids=[artifact1.short_id],
)
self.assertEqual(len(contents), 1)
self.assertIn(artifact1.short_id, contents)
self.assertNotIn(artifact2.short_id, contents)
class TestArtifactTypeRegistry(BaseTest):
def setUp(self):
super().setUp()
self.manager = ArtifactManager(team=self.team, user=self.user)
def test_get_db_type_for_visualization_content(self):
content = VisualizationArtifactContent(query=AssistantTrendsQuery(series=[]))
db_type = self.manager._get_db_type_for_content(content)
self.assertEqual(db_type, AgentArtifact.Type.VISUALIZATION)
def test_get_db_type_for_notebook_content(self):
content = StoredNotebookArtifactContent(blocks=[])
db_type = self.manager._get_db_type_for_content(content)
self.assertEqual(db_type, AgentArtifact.Type.NOTEBOOK)