: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
import uuid
from posthog.test.base import APIBaseTest
from unittest.mock import AsyncMock, MagicMock, patch
from django.conf import settings
from django.utils import timezone
from parameterized import parameterized
from rest_framework import status
from temporalio.exceptions import WorkflowAlreadyStartedError
from posthog.constants import AvailableFeature
from posthog.models import OrganizationMembership
from posthog.models.scoping import team_scope
from posthog.models.team import Team
from posthog.rate_limit import AIBurstRateThrottle, AISustainedRateThrottle
from posthog.slo.types import SloOperation
from products.access_control.backend.models.access_control import AccessControl
from products.product_analytics.backend.facade.models import Insight
from products.pulse.backend.api.brief import ProductBriefViewSet
from products.pulse.backend.models import BriefConfig, ProductBrief
def _temporal_client() -> MagicMock:
client = MagicMock()
client.start_workflow = AsyncMock()
return client
@patch("posthoganalytics.feature_enabled", return_value=True)
@patch("products.pulse.backend.api.brief.sync_connect")
class TestPulseAPI(APIBaseTest):
def setUp(self) -> None:
super().setUp()
self.organization.is_ai_data_processing_approved = True
self.organization.save()
def test_generate_requires_flag(self, mock_connect: MagicMock, mock_flag: MagicMock) -> None:
mock_flag.return_value = False
response = self.client.post(f"/api/projects/{self.team.id}/pulse/briefs/generate/")
assert response.status_code == status.HTTP_403_FORBIDDEN
mock_connect.assert_not_called()
def test_generate_requires_ai_consent(self, mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
self.organization.is_ai_data_processing_approved = False
self.organization.save()
response = self.client.post(f"/api/projects/{self.team.id}/pulse/briefs/generate/")
assert response.status_code == status.HTTP_400_BAD_REQUEST
# The frontend matches this code to show the consent banner — it is part of the API contract.
assert response.json()["code"] == "ai_consent_required"
mock_connect.assert_not_called()
def test_generate_creates_brief_and_starts_workflow(self, mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
client = _temporal_client()
mock_connect.return_value = client
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/briefs/generate/",
{"period": {"period_type": "last_n_days", "days": 14}},
format="json",
)
assert response.status_code == status.HTTP_201_CREATED, response.json()
brief = ProductBrief.objects.for_team(self.team.pk).get(id=response.json()["id"])
assert brief.status == ProductBrief.Status.GENERATING
assert brief.trigger == ProductBrief.Trigger.ON_DEMAND
assert brief.period == {"type": "last_n_days", "days": 14}
client.start_workflow.assert_called_once()
assert client.start_workflow.call_args.kwargs["task_queue"] == settings.ANALYTICS_PLATFORM_TASK_QUEUE
assert client.start_workflow.call_args.kwargs["execution_timeout"] is not None
# The workflow input carries an SLO config so the interceptor emits started/completed metrics.
workflow_input = client.start_workflow.call_args.args[1]
assert workflow_input.slo is not None
assert workflow_input.slo.operation == SloOperation.PULSE_BRIEF_GENERATION
assert workflow_input.slo.resource_id == str(brief.id)
assert client.start_workflow.call_args.kwargs["id"] == f"pulse-brief-{self.team.id}-default"
def test_generate_scopes_workflow_to_config(self, mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
client = _temporal_client()
mock_connect.return_value = client
with team_scope(self.team.pk, canonical=True):
config = BriefConfig.objects.create(team=self.team, created_by=self.user, name="Configured")
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/briefs/generate/", {"config_id": str(config.id)}
)
assert response.status_code == status.HTTP_201_CREATED, response.json()
assert client.start_workflow.call_args.kwargs["id"] == f"pulse-brief-{self.team.id}-{config.id}"
def test_generate_uses_ai_throttles(self, _mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
view = ProductBriefViewSet()
view.action = "generate"
assert [type(throttle) for throttle in view.get_throttles()] == [
AIBurstRateThrottle,
AISustainedRateThrottle,
]
def test_generate_token_requires_source_read_scopes(self, mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
api_key = self.create_personal_api_key_with_scopes(["project:write"])
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/briefs/generate/",
headers={"authorization": f"Bearer {api_key}"},
)
assert response.status_code == status.HTTP_403_FORBIDDEN
assert response.json()["detail"] == "API key missing required scope 'annotation:read'"
mock_connect.assert_not_called()
def test_generate_token_with_source_read_scopes_is_allowed(
self, mock_connect: MagicMock, _mock_flag: MagicMock
) -> None:
mock_connect.return_value = _temporal_client()
api_key = self.create_personal_api_key_with_scopes(
["project:write", "annotation:read", "subscription:read", "alert:read", "insight:read"]
)
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/briefs/generate/",
headers={"authorization": f"Bearer {api_key}"},
)
assert response.status_code == status.HTTP_201_CREATED, response.json()
def test_retrieve_token_requires_source_read_scopes(self, _mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
with team_scope(self.team.pk, canonical=True):
brief = ProductBrief.objects.create(
team=self.team,
created_by=self.user,
trigger=ProductBrief.Trigger.ON_DEMAND,
)
api_key = self.create_personal_api_key_with_scopes(["project:read"])
response = self.client.get(
f"/api/projects/{self.team.id}/pulse/briefs/{brief.id}/",
headers={"authorization": f"Bearer {api_key}"},
)
assert response.status_code == status.HTTP_403_FORBIDDEN
assert response.json()["detail"] == "API key missing required scope 'annotation:read'"
@patch("products.pulse.backend.api.brief.report_user_action")
def test_generate_while_running_returns_409_without_orphan_brief(
self, mock_report: MagicMock, mock_connect: MagicMock, _mock_flag: MagicMock
) -> None:
client = _temporal_client()
client.start_workflow.side_effect = WorkflowAlreadyStartedError("pulse-brief-x", "pulse-generate-brief")
mock_connect.return_value = client
response = self.client.post(f"/api/projects/{self.team.id}/pulse/briefs/generate/")
assert response.status_code == status.HTTP_409_CONFLICT
assert not ProductBrief.objects.for_team(self.team.pk).exists()
# Contention is a distinct analytics signal from a successful generate.
assert "pulse brief generation contended" in [call.args[1] for call in mock_report.call_args_list]
def test_generate_dispatch_failure_returns_500_with_brief_id_and_status(
self, mock_connect: MagicMock, _mock_flag: MagicMock
) -> None:
client = _temporal_client()
client.start_workflow.side_effect = RuntimeError("temporal down")
mock_connect.return_value = client
response = self.client.post(f"/api/projects/{self.team.id}/pulse/briefs/generate/")
assert response.status_code == status.HTTP_500_INTERNAL_SERVER_ERROR
brief = ProductBrief.objects.for_team(self.team.pk).get()
assert brief.status == ProductBrief.Status.FAILED
assert "temporal down" in (brief.error or "")
# The failed row's id+status is returned so the frontend can surface/deep-link it.
assert response.json()["brief"] == {"id": str(brief.id), "status": ProductBrief.Status.FAILED.value}
def test_generate_with_unknown_config_returns_400(self, mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
other_team = Team.objects.create(organization=self.organization, name="other")
with team_scope(other_team.pk, canonical=True):
foreign_config = BriefConfig.objects.create(team=other_team, name="foreign")
for config_id in [str(foreign_config.id), str(uuid.uuid4())]:
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/briefs/generate/", {"config_id": config_id}
)
assert response.status_code == status.HTTP_400_BAD_REQUEST, config_id
assert "Brief config not found." in str(response.json())
assert not ProductBrief.objects.for_team(self.team.pk).exists()
mock_connect.assert_not_called()
def test_briefs_are_team_scoped(self, _mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
other_team = Team.objects.create(organization=self.organization, name="other")
with team_scope(other_team.pk, canonical=True):
other_brief = ProductBrief.objects.create(team=other_team, trigger=ProductBrief.Trigger.ON_DEMAND)
response = self.client.get(f"/api/projects/{self.team.id}/pulse/briefs/")
assert response.status_code == status.HTTP_200_OK
assert str(other_brief.id) not in [row["id"] for row in response.json()["results"]]
def test_configs_and_briefs_are_creator_scoped(self, _mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
other_user = self._create_user("[email protected]")
with team_scope(self.team.pk, canonical=True):
other_config = BriefConfig.objects.create(team=self.team, created_by=other_user, name="private")
other_brief = ProductBrief.objects.create(
team=self.team,
created_by=other_user,
config=other_config,
trigger=ProductBrief.Trigger.ON_DEMAND,
)
configs = self.client.get(f"/api/projects/{self.team.id}/pulse/brief_configs/").json()["results"]
briefs = self.client.get(f"/api/projects/{self.team.id}/pulse/briefs/").json()["results"]
assert str(other_config.id) not in [row["id"] for row in configs]
assert str(other_brief.id) not in [row["id"] for row in briefs]
def test_project_member_can_mutate_and_generate(self, mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
mock_connect.return_value = _temporal_client()
self.organization_membership.level = OrganizationMembership.Level.MEMBER
self.organization_membership.save()
self.organization.available_product_features = [
{"key": AvailableFeature.ACCESS_CONTROL, "name": AvailableFeature.ACCESS_CONTROL},
{"key": AvailableFeature.ROLE_BASED_ACCESS, "name": AvailableFeature.ROLE_BASED_ACCESS},
]
self.organization.save()
AccessControl.objects.create(
team=self.team,
resource="project",
resource_id=str(self.team.id),
access_level="member",
)
list_response = self.client.get(f"/api/projects/{self.team.id}/pulse/brief_configs/")
create_response = self.client.post(f"/api/projects/{self.team.id}/pulse/brief_configs/", {"name": "allowed"})
generate_response = self.client.post(f"/api/projects/{self.team.id}/pulse/briefs/generate/")
assert list_response.status_code == status.HTTP_200_OK
assert create_response.status_code == status.HTTP_201_CREATED
assert generate_response.status_code == status.HTTP_201_CREATED
mock_connect.assert_called_once()
def test_config_crud_roundtrip(self, _mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
insight = Insight.objects.create(team=self.team, name="Pageviews")
create_response = self.client.post(
f"/api/projects/{self.team.id}/pulse/brief_configs/",
{
"name": "Feature flags focus",
"focus_prompt": "flags team",
"anchors": {"insights": [insight.short_id]},
},
)
assert create_response.status_code == status.HTTP_201_CREATED, create_response.json()
config_id = create_response.json()["id"]
list_response = self.client.get(f"/api/projects/{self.team.id}/pulse/brief_configs/")
assert list_response.status_code == status.HTTP_200_OK
assert [row["id"] for row in list_response.json()["results"]] == [config_id]
patch_response = self.client.patch(
f"/api/projects/{self.team.id}/pulse/brief_configs/{config_id}/", {"name": "Renamed"}
)
assert patch_response.status_code == status.HTTP_200_OK
assert patch_response.json()["name"] == "Renamed"
with team_scope(self.team.pk, canonical=True):
brief = ProductBrief.objects.create(
team=self.team, config_id=config_id, trigger=ProductBrief.Trigger.ON_DEMAND
)
delete_response = self.client.delete(f"/api/projects/{self.team.id}/pulse/brief_configs/{config_id}/")
assert delete_response.status_code == status.HTTP_204_NO_CONTENT
assert self.client.get(f"/api/projects/{self.team.id}/pulse/brief_configs/").json()["results"] == []
# Soft delete: brief history keeps its config pointer and the row is recoverable.
brief.refresh_from_db()
assert str(brief.config_id) == config_id
restore_response = self.client.patch(
f"/api/projects/{self.team.id}/pulse/brief_configs/{config_id}/", {"deleted": False}
)
assert restore_response.status_code == status.HTTP_200_OK
assert [
row["id"] for row in self.client.get(f"/api/projects/{self.team.id}/pulse/brief_configs/").json()["results"]
] == [config_id]
def test_generate_with_soft_deleted_config_returns_400(
self, mock_connect: MagicMock, _mock_flag: MagicMock
) -> None:
with team_scope(self.team.pk, canonical=True):
config = BriefConfig.objects.create(team=self.team, name="gone", deleted=True)
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/briefs/generate/", {"config_id": str(config.id)}
)
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert "Brief config not found." in str(response.json())
mock_connect.assert_not_called()
def test_config_rejects_unavailable_anchor(self, _mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/brief_configs/",
{"name": "Restricted", "anchors": {"insights": ["missing"]}},
format="json",
)
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert "anchored insights are unavailable" in str(response.json())
def test_generate_revalidates_config_anchors(self, mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
with team_scope(self.team.pk, canonical=True):
config = BriefConfig.objects.create(
team=self.team,
created_by=self.user,
name="Stale access",
anchors={"insights": ["missing"]},
)
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/briefs/generate/", {"config_id": str(config.id)}
)
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert "anchored insights are unavailable" in str(response.json())
mock_connect.assert_not_called()
def test_config_focus_prompt_length_capped(self, _mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/brief_configs/",
{"name": "too long", "focus_prompt": "x" * 2001},
)
assert response.status_code == status.HTTP_400_BAD_REQUEST
assert response.json()["attr"] == "focus_prompt"
def test_config_settings_round_trip_and_range_validated(
self, _mock_connect: MagicMock, _mock_flag: MagicMock
) -> None:
# Valid knobs persist; an out-of-range knob is rejected at the serializer (wiring guard).
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/brief_configs/",
{"name": "Tuned", "settings": {"confidence_threshold": 0.8}},
format="json",
)
assert response.status_code == status.HTTP_201_CREATED, response.json()
assert response.json()["settings"]["confidence_threshold"] == 0.8
bad = self.client.post(
f"/api/projects/{self.team.id}/pulse/brief_configs/",
{"name": "Bad", "settings": {"confidence_threshold": 5.0}},
format="json",
)
assert bad.status_code == status.HTTP_400_BAD_REQUEST
@parameterized.expand(
[
("brief_configs", BriefConfig, {"name": "tie"}),
("briefs", ProductBrief, {"trigger": ProductBrief.Trigger.ON_DEMAND}),
]
)
def test_list_pages_do_not_repeat_or_skip_rows_on_a_created_at_tie(
self,
_mock_connect: MagicMock,
_mock_flag: MagicMock,
route: str,
model: type[BriefConfig] | type[ProductBrief],
extra_fields: dict,
) -> None:
# Ascending ids in insertion order, so the physical row order contradicts the newest-first
# order the list owes. created_at is auto_now_add, so the tie is forced after the insert.
row_ids = [uuid.UUID(f"018f0000-0000-7000-8000-00000000000{n}") for n in range(1, 5)]
with team_scope(self.team.pk, canonical=True):
for row_id in row_ids:
model.objects.create(id=row_id, team=self.team, created_by=self.user, **extra_fields)
model.objects.filter(pk__in=row_ids).update(created_at=timezone.now())
paged: list[str] = []
for offset in (0, 2):
response = self.client.get(f"/api/projects/{self.team.id}/pulse/{route}/?limit=2&offset={offset}")
assert response.status_code == status.HTTP_200_OK
paged += [row["id"] for row in response.json()["results"]]
assert paged == [str(row_id) for row_id in sorted(row_ids, reverse=True)]
def test_generate_rejects_last_n_days_without_days(self, mock_connect: MagicMock, _mock_flag: MagicMock) -> None:
response = self.client.post(
f"/api/projects/{self.team.id}/pulse/briefs/generate/",
{"period": {"period_type": "last_n_days"}},
format="json",
)
assert response.status_code == status.HTTP_400_BAD_REQUEST
mock_connect.assert_not_called()