: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 datetime import UTC, datetime, timedelta
from typing import Any
from uuid import UUID, uuid4
from posthog.test.base import BaseTest
from unittest.mock import MagicMock, patch
from django.conf import settings
from django.core.cache import cache
from django.utils import timezone
from parameterized import parameterized
from slack_sdk.errors import SlackApiError
from posthog.models import Team
from posthog.models.comment import Comment
from products.conversations.backend.channel_summary_ids import build_channel_summary_workflow_id
from products.conversations.backend.facade.api import (
SupportMessageSendError,
SupportSenderIdentityUnavailable,
SupportSlackSender,
get_public_human_replies,
list_account_ticket_messages,
list_account_tickets,
list_resolved_ticket_revisions,
post_support_message,
resolve_support_slack_sender,
trigger_immediate_channel_summary,
)
from products.conversations.backend.models.constants import Status
from products.conversations.backend.models.ticket import Ticket
CLIENT = "products.conversations.backend.facade.api.get_slack_client"
FACADE = "products.conversations.backend.facade.api"
class FakeSlackResponse(dict):
# Mimics slack_sdk's SlackResponse: .get() reads the JSON body, HTTP headers are an attribute.
def __init__(self, data: dict, headers: dict | None = None) -> None:
super().__init__(data)
self.headers = headers or {}
class TestPostSupportMessage(BaseTest):
@patch(CLIENT)
def test_applies_configured_bot_identity(self, mock_get_client: MagicMock):
self.team.conversations_settings = {
"slack_bot_display_name": "SupportBot",
"slack_bot_icon_url": "https://example.com/icon.png",
}
self.team.save()
client = MagicMock()
client.chat_postMessage.return_value = {"ts": "111.222"}
mock_get_client.return_value = client
ts = post_support_message(self.team.pk, "C1", "hello team")
assert ts == "111.222"
kwargs = client.chat_postMessage.call_args.kwargs
assert kwargs["channel"] == "C1"
assert kwargs["text"] == "hello team"
assert kwargs["username"] == "SupportBot"
assert kwargs["icon_url"] == "https://example.com/icon.png"
@patch(CLIENT)
def test_sender_overrides_the_bot_identity(self, mock_get_client: MagicMock):
self.team.conversations_settings = {
"slack_bot_display_name": "SupportBot",
"slack_bot_icon_url": "https://example.com/bot.png",
}
self.team.save()
client = MagicMock()
client.chat_postMessage.return_value = {"ts": "111.222"}
mock_get_client.return_value = client
post_support_message(
self.team.pk,
"C1",
"hello team",
sender=SupportSlackSender(name="Ada", icon_url="https://example.com/ada.png"),
)
kwargs = client.chat_postMessage.call_args.kwargs
assert kwargs["username"] == "Ada"
assert kwargs["icon_url"] == "https://example.com/ada.png"
@patch(CLIENT)
def test_sender_without_avatar_keeps_the_name_only(self, mock_get_client: MagicMock):
self.team.conversations_settings = {"slack_bot_icon_url": "https://example.com/bot.png"}
self.team.save()
client = MagicMock()
client.chat_postMessage.return_value = {"ts": "111.222"}
mock_get_client.return_value = client
post_support_message(self.team.pk, "C1", "hi", sender=SupportSlackSender(name="Ada", icon_url=""))
kwargs = client.chat_postMessage.call_args.kwargs
assert kwargs["username"] == "Ada"
# The bot icon would contradict the name, so it is not applied.
assert "icon_url" not in kwargs
@parameterized.expand(
[
(
"slack_rate_limited",
SlackApiError(
message="x",
response=FakeSlackResponse({"error": "ratelimited"}, headers={"Retry-After": "7"}),
),
None,
"ratelimited",
7.0,
),
("transport_error", ConnectionError("boom"), None, "transport_error", None),
("missing_ts", None, {"ok": True}, "missing_ts", None),
]
)
@patch(CLIENT)
def test_translates_send_failures(
self,
_name: str,
side_effect: Exception | None,
return_value: dict | None,
expected_code: str,
expected_retry_after: float | None,
mock_get_client: MagicMock,
):
client = MagicMock()
if side_effect is not None:
client.chat_postMessage.side_effect = side_effect
else:
client.chat_postMessage.return_value = return_value
mock_get_client.return_value = client
with self.assertRaises(SupportMessageSendError) as ctx:
post_support_message(self.team.pk, "C1", "hi")
assert ctx.exception.code == expected_code
assert ctx.exception.retry_after == expected_retry_after
class TestResolveSupportSlackSender(BaseTest):
def setUp(self) -> None:
super().setUp()
cache.clear()
def _client_returning(self, data: dict) -> MagicMock:
client = MagicMock()
client.users_lookupByEmail.return_value.data = data
return client
@patch(CLIENT)
def test_resolves_workspace_member_by_email(self, mock_get_client: MagicMock):
mock_get_client.return_value = self._client_returning(
{"ok": True, "user": {"profile": {"display_name": "Ada", "image_72": "https://example.com/ada.png"}}}
)
sender = resolve_support_slack_sender(self.team.pk, "[email protected]")
assert sender == SupportSlackSender(name="Ada", icon_url="https://example.com/ada.png")
@patch(CLIENT)
def test_returns_none_when_no_slack_user_has_the_email(self, mock_get_client: MagicMock):
mock_get_client.return_value = self._client_returning({"ok": False, "error": "users_not_found"})
assert resolve_support_slack_sender(self.team.pk, "[email protected]") is None
@patch(CLIENT)
def test_refuses_when_the_install_cannot_post_a_custom_identity(self, mock_get_client: MagicMock):
# Slack would reject every such post, so fail before resolving a profile we can't use.
self.team.conversations_settings = {"slack_scopes": ["chat:write", "users:read.email"]}
self.team.save()
client = self._client_returning({"ok": True, "user": {"profile": {"display_name": "Ada"}}})
mock_get_client.return_value = client
with self.assertRaises(SupportSenderIdentityUnavailable):
resolve_support_slack_sender(self.team.pk, "[email protected]")
client.users_lookupByEmail.assert_not_called()
@patch(CLIENT)
def test_allows_an_install_whose_scopes_were_never_recorded(self, mock_get_client: MagicMock):
# Predates scope recording, and the scope has been requested for longer than that — so an
# empty list is "unknown", not "missing", and refusing would block a working install.
self.team.conversations_settings = {"slack_enabled": True}
self.team.save()
mock_get_client.return_value = self._client_returning(
{"ok": True, "user": {"profile": {"display_name": "Ada"}}}
)
assert resolve_support_slack_sender(self.team.pk, "[email protected]") == SupportSlackSender(
name="Ada", icon_url=""
)
class TestListAccountTickets(BaseTest):
def setUp(self) -> None:
super().setUp()
self.access_control = MagicMock()
self.access_control.filter_queryset_by_access_level.side_effect = lambda queryset: queryset
def _create_ticket(self, *, team: Team, organization_id: str | None, number: int, last_message_at=None) -> Ticket:
return Ticket.objects.create(
team=team,
ticket_number=number,
widget_session_id=f"s{number}",
distinct_id=f"d{number}",
organization_id=organization_id,
last_message_at=last_message_at,
)
def test_returns_only_tickets_for_this_team_and_org(self):
other_team = Team.objects.create(organization=self.organization)
mine = self._create_ticket(team=self.team, organization_id="acct-1", number=1)
self._create_ticket(team=self.team, organization_id="acct-2", number=2)
self._create_ticket(team=other_team, organization_id="acct-1", number=1)
result = list_account_tickets(self.team.pk, "acct-1", self.access_control)
assert [t.id for t in result] == [str(mine.id)]
assert result[0].deep_link.endswith(f"/project/{self.team.pk}/support/tickets/1")
def test_returns_latest_public_message_sender(self):
ticket = self._create_ticket(
team=self.team,
organization_id="acct-1",
number=1,
last_message_at=timezone.now(),
)
ticket.anonymous_traits = {"name": "Example customer", "email": "[email protected]"}
ticket.save(update_fields=["anonymous_traits"])
Comment.objects.create(
team=self.team,
created_by=self.user,
scope="conversations_ticket",
item_id=str(ticket.id),
content="Support reply",
item_context={"author_type": "support", "is_private": False},
)
Comment.objects.create(
team=self.team,
scope="conversations_ticket",
item_id=str(ticket.id),
content="Customer reply",
item_context={"author_type": "customer", "is_private": False},
)
Comment.objects.create(
team=self.team,
created_by=self.user,
scope="conversations_ticket",
item_id=str(ticket.id),
content="Private note",
item_context={"author_type": "support", "is_private": True},
)
result = list_account_tickets(self.team.pk, "acct-1", self.access_control)
assert result[0].last_message is not None
assert result[0].last_message.sender.name == "Example customer"
assert result[0].last_message.sender.email == "[email protected]"
assert result[0].last_message.sender.distinct_id == ticket.distinct_id
assert result[0].last_message.direction == "inbound"
message_page = list_account_ticket_messages(self.team.pk, "acct-1", str(ticket.id), self.access_control)
assert message_page is not None
messages, count = message_page
assert count == 3
assert [message.content for message in messages] == ["Support reply", "Customer reply", "Private note"]
assert [message.direction for message in messages] == ["outbound", "inbound", "outbound"]
assert messages[-1].is_private is True
def test_returns_imported_support_sender_without_a_posthog_user(self):
ticket = self._create_ticket(
team=self.team,
organization_id="acct-1",
number=1,
last_message_at=timezone.now(),
)
Comment.objects.create(
team=self.team,
scope="conversations_ticket",
item_id=str(ticket.id),
content="Imported support reply",
item_context={
"author_type": "support",
"author_name": "Imported agent",
"author_email": "[email protected]",
"is_private": False,
},
)
result = list_account_tickets(self.team.pk, "acct-1", self.access_control)
assert result[0].last_message is not None
assert result[0].last_message.sender.name == "Imported agent"
assert result[0].last_message.sender.email == "[email protected]"
assert result[0].last_message.direction == "outbound"
@parameterized.expand(
[
(
"slack",
{
"author_type": "customer",
"slack_author_name": "Slack responder",
"slack_author_email": "[email protected]",
},
"Slack responder",
"[email protected]",
),
(
"teams",
{
"author_type": "customer",
"teams_author_name": "Teams responder",
"teams_author_email": "[email protected]",
},
"Teams responder",
"[email protected]",
),
(
# GitHub gives no per-comment email, so the address stays the ticket requester's.
"github",
{"author_type": "customer", "from_github": True, "github_login": "github-responder"},
"github-responder",
"[email protected]",
),
(
"email",
{"author_type": "customer", "email_from_name": "Email responder", "email_from": "[email protected]"},
"Email responder",
"[email protected]",
),
]
)
def test_returns_channel_specific_inbound_sender(
self,
_name: str,
item_context: dict[str, Any],
expected_name: str,
expected_email: str | None,
) -> None:
ticket = self._create_ticket(
team=self.team,
organization_id="acct-1",
number=1,
last_message_at=timezone.now(),
)
ticket.anonymous_traits = {"name": "Thread starter", "email": "[email protected]"}
ticket.save(update_fields=["anonymous_traits"])
Comment.objects.create(
team=self.team,
scope="conversations_ticket",
item_id=str(ticket.id),
content="Channel reply",
item_context=item_context,
)
tickets = list_account_tickets(self.team.pk, "acct-1", self.access_control)
message_page = list_account_ticket_messages(self.team.pk, "acct-1", str(ticket.id), self.access_control)
assert tickets[0].last_message is not None
assert tickets[0].last_message.sender.name == expected_name
assert tickets[0].last_message.sender.email == expected_email
assert message_page is not None
assert message_page[0][0].author_name == expected_name
def test_orders_by_last_message_activity_with_nulls_last(self):
older = timezone.now() - timedelta(hours=1)
newer = timezone.now()
self._create_ticket(team=self.team, organization_id="acct-1", number=1, last_message_at=older)
self._create_ticket(team=self.team, organization_id="acct-1", number=2, last_message_at=newer)
self._create_ticket(team=self.team, organization_id="acct-1", number=3, last_message_at=None)
result = list_account_tickets(self.team.pk, "acct-1", self.access_control)
assert [t.ticket_number for t in result] == [2, 1, 3]
def test_empty_organization_id_matches_nothing(self):
self._create_ticket(team=self.team, organization_id="acct-1", number=1)
assert list_account_tickets(self.team.pk, "", self.access_control) == []
ACCOUNT_ID = "e1f4a5b6-0000-4000-8000-000000000001"
PERIOD_START = datetime(2026, 7, 27, tzinfo=UTC)
class TestTriggerImmediateChannelSummary(BaseTest):
def _trigger(self) -> bool:
return trigger_immediate_channel_summary(
team_id=self.team.pk,
account_id=ACCOUNT_ID,
account_name="Acme Corp",
slack_channel_id="C123",
cadence="daily",
period_start=PERIOD_START,
period_end=PERIOD_START + timedelta(days=1),
)
@parameterized.expand(
[
("eligible", True, "xoxb-token", True),
("ai_processing_not_approved", False, "xoxb-token", False),
("support_bot_not_configured", True, "", False),
]
)
def test_gates_on_org_approval_and_bot_config(self, _name, ai_approved, bot_token, expected_dispatch):
self.organization.is_ai_data_processing_approved = ai_approved
self.organization.save()
with (
patch(f"{FACADE}.get_support_slack_bot_token", return_value=bot_token),
patch(f"{FACADE}.sync_connect") as connect,
patch(f"{FACADE}.asyncio.run") as run,
):
dispatched = self._trigger()
assert dispatched is expected_dispatch
assert connect.called is expected_dispatch
assert run.called is expected_dispatch
def test_dispatches_under_the_shared_workflow_id(self):
self.organization.is_ai_data_processing_approved = True
self.organization.save()
client = MagicMock()
with (
patch(f"{FACADE}.get_support_slack_bot_token", return_value="xoxb-token"),
patch(f"{FACADE}.sync_connect", return_value=client),
patch(f"{FACADE}.asyncio.run"),
):
self._trigger()
assert client.start_workflow.call_args.kwargs["id"] == build_channel_summary_workflow_id(
account_id=ACCOUNT_ID, cadence="daily", period_start=PERIOD_START.date()
)
assert client.start_workflow.call_args.args[1].slack_channel_id == "C123"
LOOKBACK = timedelta(days=7)
class TestResolvedTicketEvidence(BaseTest):
def setUp(self) -> None:
super().setUp()
self.team.conversations_enabled = True
self.team.save(update_fields=["conversations_enabled"])
self.since = timezone.now() - LOOKBACK
def _ticket(self, *, team: Team | None = None, status: str = Status.RESOLVED, number: int = 1) -> Ticket:
team = team or self.team
return Ticket.objects.create(
team=team,
ticket_number=number,
widget_session_id=f"s{number}-{team.id}",
distinct_id=f"d{number}-{team.id}",
status=status,
)
def _comment(
self,
ticket: Ticket,
*,
author_type: str,
content: str,
is_private: bool | None = False,
deleted: bool = False,
extra_context: dict[str, str] | None = None,
) -> Comment:
item_context: dict = {"author_type": author_type}
if is_private is not None:
item_context["is_private"] = is_private
if extra_context:
item_context.update(extra_context)
return Comment.objects.create(
team=ticket.team,
scope="conversations_ticket",
item_id=str(ticket.id),
content=content,
deleted=deleted,
item_context=item_context,
)
def _revisions(
self,
*,
team: Team | None = None,
limit: int = 10,
offset: int = 0,
ticket_id: UUID | None = None,
):
return list_resolved_ticket_revisions(
(team or self.team).id,
since=self.since,
limit=limit,
offset=offset,
ticket_id=ticket_id,
)
def test_returns_only_public_human_reply_text(self) -> None:
ticket = self._ticket()
self._comment(
ticket,
author_type="customer",
content="Customer asked about the rate limit",
extra_context={"author_name": "Ada", "author_email": "[email protected]"},
)
human = self._comment(
ticket,
author_type="support",
content="The rate limit is 1000 events per hour",
extra_context={"author_name": "Support agent", "author_email": "[email protected]"},
)
self._comment(ticket, author_type="support", content="Private diagnosis", is_private=True)
self._comment(ticket, author_type="AI", content="AI suggested a reply")
self._comment(ticket, author_type="team", content="Team analytics author type")
revisions = self._revisions()
replies = get_public_human_replies(self.team.id, ticket.id)
assert [revision.ticket_id for revision in revisions] == [ticket.id]
assert revisions[0].resolution_comment_id == human.id
assert revisions[0].revision_at == human.created_at
assert replies is not None
assert replies.replies == ("The rate limit is 1000 events per hour",)
@parameterized.expand(
[
("customer", "customer", False, False, "Customer said this"),
("ai", "AI", False, False, "AI drafted this"),
("team", "team", False, False, "Team analytics type"),
("private_support", "support", True, False, "Internal note"),
("deleted_support", "support", False, True, "Retracted reply"),
("empty_content", "support", False, False, ""),
("whitespace_only", "support", False, False, " "),
]
)
def test_collect_skips_tickets_without_a_public_human_reply(
self,
_name: str,
author_type: str,
is_private: bool,
deleted: bool,
content: str,
) -> None:
ticket = self._ticket()
self._comment(
ticket,
author_type=author_type,
content=content,
is_private=is_private,
deleted=deleted,
)
assert self._revisions() == []
assert get_public_human_replies(self.team.id, ticket.id) is None
@parameterized.expand(
[
("support", "support", False),
("human", "human", False),
("missing_is_private_key", "support", None),
]
)
def test_collect_includes_public_human_author_types(
self,
_name: str,
author_type: str,
is_private: bool | None,
) -> None:
ticket = self._ticket()
comment = self._comment(ticket, author_type=author_type, content="Reusable answer", is_private=is_private)
revisions = self._revisions()
replies = get_public_human_replies(self.team.id, ticket.id)
assert [revision.resolution_comment_id for revision in revisions] == [comment.id]
assert replies is not None
assert replies.replies == ("Reusable answer",)
def test_revision_follows_the_latest_public_human_comment(self) -> None:
ticket = self._ticket()
first = self._comment(ticket, author_type="support", content="First answer")
later = self._comment(ticket, author_type="human", content="Follow-up answer")
self._comment(ticket, author_type="AI", content="Later AI note")
self._comment(ticket, author_type="support", content="Deleted later", deleted=True)
now = timezone.now()
Comment.objects.filter(pk=first.id).update(created_at=now - timedelta(minutes=2))
Comment.objects.filter(pk=later.id).update(created_at=now - timedelta(minutes=1))
revisions = self._revisions()
replies = get_public_human_replies(self.team.id, ticket.id)
pinned = get_public_human_replies(self.team.id, ticket.id, resolution_comment_id=first.id)
assert [revision.resolution_comment_id for revision in revisions] == [later.id]
assert replies is not None
assert replies.replies == ("First answer", "Follow-up answer")
assert pinned is not None
assert pinned.replies == ("First answer",)
assert get_public_human_replies(self.team.id, ticket.id, resolution_comment_id=uuid4()) is None
def test_open_ticket_is_not_collected(self) -> None:
ticket = self._ticket(status=Status.OPEN)
self._comment(ticket, author_type="support", content="Still working on it")
assert self._revisions() == []
replies = get_public_human_replies(self.team.id, ticket.id)
assert replies is not None
assert replies.replies == ("Still working on it",)
def test_conversations_disabled_returns_nothing(self) -> None:
ticket = self._ticket()
self._comment(ticket, author_type="support", content="Reusable answer")
self.team.conversations_enabled = False
self.team.save(update_fields=["conversations_enabled"])
assert self._revisions() == []
assert get_public_human_replies(self.team.id, ticket.id) is None
def test_does_not_return_other_teams_tickets(self) -> None:
other = Team.objects.create_with_data(organization=self.organization, initiating_user=self.user)
other.conversations_enabled = True
other.save(update_fields=["conversations_enabled"])
other_ticket = self._ticket(team=other, number=1)
self._comment(other_ticket, author_type="support", content="Other team answer")
assert self._revisions() == []
assert get_public_human_replies(self.team.id, other_ticket.id) is None
def test_child_environment_reads_comments_stored_on_the_parent(self) -> None:
child = Team.objects.create(
organization=self.organization,
project=self.project,
parent_team=self.team,
name="Child environment",
conversations_enabled=True,
)
ticket = self._ticket(team=child)
comment = self._comment(ticket, author_type="support", content="Answer from the child environment")
revisions = self._revisions(team=child)
replies = get_public_human_replies(child.id, ticket.id)
assert comment.team_id == self.team.id
assert [revision.source_team_id for revision in revisions] == [child.id]
assert revisions[0].resolution_comment_id == comment.id
assert self._revisions() == []
assert replies is not None
assert replies.replies == ("Answer from the child environment",)
def test_lookback_excludes_stale_resolved_tickets(self) -> None:
ticket = self._ticket()
self._comment(ticket, author_type="support", content="Old answer")
stale = timezone.now() - timedelta(days=8)
Ticket.objects.filter(pk=ticket.id).update(updated_at=stale, last_message_at=stale)
assert self._revisions() == []
def test_pagination_and_ticket_filter_select_before_limiting(self) -> None:
older = self._ticket(number=1)
middle = self._ticket(number=2)
newer = self._ticket(number=3)
self._comment(older, author_type="support", content="Older answer")
self._comment(middle, author_type="support", content="Middle answer")
self._comment(newer, author_type="support", content="Newer answer")
Ticket.objects.filter(pk=older.id).update(
updated_at=timezone.now() - timedelta(days=8),
last_message_at=timezone.now() - timedelta(days=8),
)
Ticket.objects.filter(pk=middle.id).update(updated_at=timezone.now() - timedelta(hours=2))
Ticket.objects.filter(pk=newer.id).update(updated_at=timezone.now() - timedelta(hours=1))
revisions = self._revisions(limit=1)
second_page = self._revisions(limit=1, offset=1)
targeted = self._revisions(limit=1, ticket_id=older.id)
assert [revision.ticket_id for revision in revisions] == [newer.id]
assert [revision.ticket_id for revision in second_page] == [middle.id]
assert [revision.ticket_id for revision in targeted] == [older.id]
assert revisions[0].display_label == "ticket #3"
assert revisions[0].deep_link == f"{settings.SITE_URL}/project/{self.team.id}/support/tickets/3"