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.

refactor(dashboards): use the experiments facade in experiment widgets (#126297)

Andersaae099b1739c
diff --git a/products/dashboards/backend/api/test/test_experiment_widgets.py b/products/dashboards/backend/api/test/test_experiment_widgets.py
index 9e6caa554335..96570913207f 100644
--- a/products/dashboards/backend/api/test/test_experiment_widgets.py
+++ b/products/dashboards/backend/api/test/test_experiment_widgets.py
@@ -2,7 +2,7 @@ from concurrent.futures import Future
from typing import Any
from posthog.test.base import APIBaseTest
-from unittest.mock import MagicMock, patch
+from unittest.mock import patch
from django.test import SimpleTestCase
from django.utils import timezone
@@ -19,21 +19,18 @@ from products.dashboards.backend.widget_registry import (
EXPERIMENTS_LIST_WIDGET_TYPE,
validate_widget_config,
)
-from products.dashboards.backend.widgets.experiment_results import (
- MAX_EXPERIMENT_RESULTS_WIDGET_METRICS,
- run_experiment_results_widget,
-)
+from products.dashboards.backend.widgets.experiment_results import run_experiment_results_widget
from products.dashboards.backend.widgets.experiments_list import run_experiments_list_widget
-from products.experiments.backend.models.experiment import (
- EXPOSURE_FROZEN_GROUP_KEY,
- Experiment,
- ExperimentSavedMetric,
- ExperimentToSavedMetric,
+from products.experiments.backend.facade.contracts import (
+ ExperimentResultsWidget,
+ ExperimentResultsWidgetMetric,
+ ExperimentResultsWidgetMetrics,
)
+from products.experiments.backend.facade.testing import create_experiment
from products.feature_flags.backend.models.feature_flag import FeatureFlag
-def _block_experiment_for_member(team: Team, experiment: Experiment, member: User) -> None:
+def _block_experiment_for_member(team: Team, experiment_id: int, member: User) -> None:
from products.access_control.backend.models.access_control import AccessControl # noqa: PLC0415
team.organization.available_product_features = [{"key": AvailableFeature.ACCESS_CONTROL, "name": "Access control"}]
@@ -42,7 +39,7 @@ def _block_experiment_for_member(team: Team, experiment: Experiment, member: Use
AccessControl.objects.create(
team=team,
resource="experiment",
- resource_id=str(experiment.id),
+ resource_id=str(experiment_id),
organization_member=membership,
access_level="none",
)
@@ -92,40 +89,36 @@ class TestExperimentsListWidget(APIBaseTest):
start_date: Any = None,
end_date: Any = None,
flag_active: bool = True,
- exposure_frozen: bool = False,
- ) -> Experiment:
+ deleted: bool = False,
+ ) -> int:
feature_flag = FeatureFlag.objects.create(
team=self.team,
key=f"flag-{name}",
created_by=created_by or self.user,
active=flag_active,
- filters=(
- {"groups": [{"properties": [], "rollout_percentage": 100, EXPOSURE_FROZEN_GROUP_KEY: True}]}
- if exposure_frozen
- else {}
- ),
)
- return Experiment.objects.create(
- team=self.team,
+ return create_experiment(
+ team_id=self.team.id,
name=name,
- feature_flag=feature_flag,
- created_by=created_by or self.user,
+ feature_flag_id=feature_flag.id,
+ created_by_id=(created_by or self.user).id,
start_date=start_date,
end_date=end_date,
+ deleted=deleted,
)
def test_lists_experiments_with_serialized_rows(self) -> None:
- experiment = self._create_experiment("Running test", start_date=timezone.now())
+ experiment_id = self._create_experiment("Running test", start_date=timezone.now())
result = run_experiments_list_widget(self.team, {}, user=self.user)
assert result["totalCount"] == 1
assert result["hasMore"] is False
row = result["results"][0]
- assert row["id"] == experiment.id
+ assert row["id"] == experiment_id
assert row["name"] == "Running test"
assert row["status"] == "running"
- assert row["feature_flag_key"] == experiment.feature_flag.key
+ assert row["feature_flag_key"] == "flag-Running test"
assert row["created_by"]["email"] == self.user.email
@parameterized.expand(
@@ -133,7 +126,6 @@ class TestExperimentsListWidget(APIBaseTest):
("draft", "draft"),
("running", "running"),
("paused", "paused"),
- ("exposure_frozen", "exposure_frozen"),
("stopped", "stopped"),
]
)
@@ -143,13 +135,11 @@ class TestExperimentsListWidget(APIBaseTest):
"draft": "Draft exp",
"running": "Running exp",
"paused": "Paused exp",
- "exposure_frozen": "Frozen exp",
"stopped": "Stopped exp",
}
self._create_experiment("Draft exp")
self._create_experiment("Running exp", start_date=now)
self._create_experiment("Paused exp", start_date=now, flag_active=False)
- self._create_experiment("Frozen exp", start_date=now, exposure_frozen=True)
self._create_experiment("Stopped exp", start_date=now, end_date=now)
result = run_experiments_list_widget(self.team, {"status": status_filter}, user=self.user)
@@ -167,9 +157,7 @@ class TestExperimentsListWidget(APIBaseTest):
assert [row["name"] for row in result["results"]] == ["Theirs"]
def test_excludes_deleted_and_other_team_experiments(self) -> None:
- deleted = self._create_experiment("Deleted")
- deleted.deleted = True
- deleted.save()
+ self._create_experiment("Deleted", deleted=True)
self._create_experiment("Kept")
result = run_experiments_list_widget(self.team, {}, user=self.user)
@@ -187,15 +175,15 @@ class TestExperimentsListWidget(APIBaseTest):
assert result["hasMore"] is True
def test_excludes_experiments_the_user_cannot_access(self) -> None:
- visible = self._create_experiment("Visible")
- blocked = self._create_experiment("Blocked")
+ visible_id = self._create_experiment("Visible")
+ blocked_id = self._create_experiment("Blocked")
member = User.objects.create_and_join(self.organization, "[email protected]", "pw")
- _block_experiment_for_member(self.team, blocked, member)
+ _block_experiment_for_member(self.team, blocked_id, member)
result = run_experiments_list_widget(self.team, {}, user=member)
assert {row["name"] for row in result["results"]} == {"Visible"}
- assert visible.id in {row["id"] for row in result["results"]}
+ assert visible_id in {row["id"] for row in result["results"]}
class TestExperimentResultsWidget(APIBaseTest):
@@ -203,19 +191,19 @@ class TestExperimentResultsWidget(APIBaseTest):
self,
name: str = "Results test",
*,
+ team: Team | None = None,
start_date: Any = None,
metrics: list[dict[str, Any]] | None = None,
- metrics_secondary: list[dict[str, Any]] | None = None,
- ) -> Experiment:
- feature_flag = FeatureFlag.objects.create(team=self.team, key=f"flag-{name}", created_by=self.user)
- return Experiment.objects.create(
- team=self.team,
+ ) -> int:
+ team = team or self.team
+ feature_flag = FeatureFlag.objects.create(team=team, key=f"flag-{name}", created_by=self.user)
+ return create_experiment(
+ team_id=team.id,
name=name,
- feature_flag=feature_flag,
- created_by=self.user,
+ feature_flag_id=feature_flag.id,
+ created_by_id=self.user.id,
start_date=start_date,
metrics=metrics or [],
- metrics_secondary=metrics_secondary or [],
)
def test_returns_needs_configuration_when_no_experiment_selected(self) -> None:
@@ -242,210 +230,107 @@ class TestExperimentResultsWidget(APIBaseTest):
def test_returns_not_found_for_other_team_experiment(self) -> None:
other_team = Team.objects.create(organization=self.organization, name="other")
- flag = FeatureFlag.objects.create(team=other_team, key="other-flag", created_by=self.user)
- experiment = Experiment.objects.create(
- team=other_team, name="Other team", feature_flag=flag, created_by=self.user
- )
+ experiment_id = self._create_experiment("Other team", team=other_team)
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
+ result = run_experiment_results_widget(self.team, {"experimentId": experiment_id}, user=self.user)
assert result == {"experiment": None, "metrics": [], "experimentNotFound": True}
def test_returns_not_found_for_experiment_the_user_cannot_access(self) -> None:
- experiment = self._create_experiment(start_date=timezone.now())
+ experiment_id = self._create_experiment(start_date=timezone.now())
member = User.objects.create_and_join(self.organization, "[email protected]", "pw")
- _block_experiment_for_member(self.team, experiment, member)
+ _block_experiment_for_member(self.team, experiment_id, member)
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=member)
+ result = run_experiment_results_widget(self.team, {"experimentId": experiment_id}, user=member)
assert result == {"experiment": None, "metrics": [], "experimentNotFound": True}
def test_draft_experiment_returns_summary_without_metrics(self) -> None:
- experiment = self._create_experiment(metrics=[_experiment_metric("uuid-1", "Mean metric")])
+ experiment_id = self._create_experiment(metrics=[_experiment_metric("uuid-1", "Mean metric")])
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
+ result = run_experiment_results_widget(self.team, {"experimentId": experiment_id}, user=self.user)
- assert result["experiment"]["id"] == experiment.id
+ assert result["experiment"]["id"] == experiment_id
assert result["experiment"]["status"] == "draft"
assert result["metrics"] == []
assert result["secondaryMetrics"] == []
assert "totalMetricsCount" not in result
assert "totalSecondaryMetricsCount" not in result
- @patch("products.dashboards.backend.widgets.experiment_results.ExperimentQueryRunner")
- def test_computes_results_for_primary_metrics(self, mock_runner_cls: MagicMock) -> None:
- mock_runner_cls.return_value.run.return_value = MagicMock(
- model_dump=lambda mode="json": {
- "kind": "NewExperimentQueryResponse",
- "baseline": {"key": "control", "number_of_samples": 100, "sum": 40, "sum_squares": 30},
- "variant_results": [{"key": "test", "number_of_samples": 100, "sum": 55, "sum_squares": 40}],
- "clickhouse_sql": "SELECT secret",
- }
- )
- experiment = self._create_experiment(
- start_date=timezone.now(),
- metrics=[_experiment_metric("uuid-1", "Mean metric")],
- )
-
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
-
- assert result["experiment"]["status"] == "running"
- assert result["totalMetricsCount"] == 1
- entry = result["metrics"][0]
- assert entry["name"] == "Mean metric"
- assert entry["error"] is None
- assert entry["metric"]["metric_type"] == "mean"
- assert entry["result"]["baseline"]["key"] == "control"
- assert "clickhouse_sql" not in entry["result"]
- query = mock_runner_cls.call_args.kwargs["query"]
- assert query.experiment_id == experiment.id
-
- @patch("products.dashboards.backend.widgets.experiment_results.ExperimentQueryRunner")
- def test_computes_results_for_secondary_metrics(self, mock_runner_cls: MagicMock) -> None:
- mock_runner_cls.return_value.run.return_value = MagicMock(
- model_dump=lambda mode="json": {
- "kind": "NewExperimentQueryResponse",
- "baseline": {"key": "control", "number_of_samples": 100, "sum": 40, "sum_squares": 30},
- "variant_results": [{"key": "test", "number_of_samples": 100, "sum": 55, "sum_squares": 40}],
- }
+ @parameterized.expand([("with_total_count", True), ("without_total_count", False)])
+ def test_serializes_the_computed_metrics(self, _label: str, include_total_count: bool) -> None:
+ start_date = timezone.now()
+ computed = ExperimentResultsWidgetMetric(
+ uuid="uuid-1",
+ name="Mean metric",
+ metric={"metric_type": "mean"},
+ result={"baseline": {"key": "control"}},
+ error=None,
)
- experiment = self._create_experiment(
- start_date=timezone.now(),
- metrics_secondary=[_experiment_metric("secondary-1", "Revenue per user")],
+ failed = ExperimentResultsWidgetMetric(
+ uuid="secondary-1", name="Broken metric", metric=None, result=None, error="Could not compute."
)
-
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
-
- assert result["metrics"] == []
- assert result["totalMetricsCount"] == 0
- assert result["totalSecondaryMetricsCount"] == 1
- entry = result["secondaryMetrics"][0]
- assert entry["name"] == "Revenue per user"
- assert entry["error"] is None
- assert entry["result"]["baseline"]["key"] == "control"
-
- @patch("products.dashboards.backend.widgets.experiment_results.ExperimentQueryRunner")
- def test_computes_both_primary_and_secondary_metrics(self, mock_runner_cls: MagicMock) -> None:
- mock_runner_cls.return_value.run.return_value = MagicMock(model_dump=lambda mode="json": {})
- experiment = self._create_experiment(
- start_date=timezone.now(),
- metrics=[_experiment_metric("uuid-1", "Primary metric")],
- metrics_secondary=[_experiment_metric("secondary-1", "Secondary metric")],
+ widget = ExperimentResultsWidget(
+ id=7,
+ name="Results test",
+ status="running",
+ start_date=start_date,
+ end_date=None,
+ feature_flag_key="flag-results",
+ metrics=ExperimentResultsWidgetMetrics(
+ primary=(computed,), secondary=(failed,), primary_total=4, secondary_total=1
+ ),
)
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
-
- assert [entry["name"] for entry in result["metrics"]] == ["Primary metric"]
- assert [entry["name"] for entry in result["secondaryMetrics"]] == ["Secondary metric"]
- assert mock_runner_cls.return_value.run.call_count == 2
-
- @patch("products.dashboards.backend.widgets.experiment_results.ExperimentQueryRunner")
- def test_caps_computed_secondary_metrics_and_reports_total(self, mock_runner_cls: MagicMock) -> None:
- mock_runner_cls.return_value.run.return_value = MagicMock(model_dump=lambda mode="json": {})
- metrics_secondary = [
- _experiment_metric(f"secondary-{index}", f"Secondary {index}")
- for index in range(MAX_EXPERIMENT_RESULTS_WIDGET_METRICS + 2)
- ]
- experiment = self._create_experiment(start_date=timezone.now(), metrics_secondary=metrics_secondary)
-
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
-
- assert result["totalSecondaryMetricsCount"] == MAX_EXPERIMENT_RESULTS_WIDGET_METRICS + 2
- assert len(result["secondaryMetrics"]) == MAX_EXPERIMENT_RESULTS_WIDGET_METRICS
- assert mock_runner_cls.return_value.run.call_count == MAX_EXPERIMENT_RESULTS_WIDGET_METRICS
+ with patch(
+ "products.dashboards.backend.widgets.experiment_results.experiment_results_widget", return_value=widget
+ ):
+ result = run_experiment_results_widget(
+ self.team, {"experimentId": 7}, user=self.user, include_total_count=include_total_count
+ )
- @patch("products.dashboards.backend.widgets.experiment_results.ExperimentQueryRunner")
- def test_caps_computed_metrics_and_reports_total(self, mock_runner_cls: MagicMock) -> None:
- mock_runner_cls.return_value.run.return_value = MagicMock(model_dump=lambda mode="json": {})
- metrics = [
- _experiment_metric(f"uuid-{index}", f"Metric {index}")
- for index in range(MAX_EXPERIMENT_RESULTS_WIDGET_METRICS + 2)
- ]
- experiment = self._create_experiment(start_date=timezone.now(), metrics=metrics)
-
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
-
- assert result["totalMetricsCount"] == MAX_EXPERIMENT_RESULTS_WIDGET_METRICS + 2
- assert len(result["metrics"]) == MAX_EXPERIMENT_RESULTS_WIDGET_METRICS
- assert mock_runner_cls.return_value.run.call_count == MAX_EXPERIMENT_RESULTS_WIDGET_METRICS
-
- @patch("products.dashboards.backend.widgets.experiment_results.ExperimentQueryRunner")
- def test_caps_primary_and_secondary_independently(self, mock_runner_cls: MagicMock) -> None:
- mock_runner_cls.return_value.run.return_value = MagicMock(model_dump=lambda mode="json": {})
- over_cap = MAX_EXPERIMENT_RESULTS_WIDGET_METRICS + 2
- experiment = self._create_experiment(
- start_date=timezone.now(),
- metrics=[_experiment_metric(f"uuid-{index}", f"Metric {index}") for index in range(over_cap)],
- metrics_secondary=[
- _experiment_metric(f"secondary-{index}", f"Secondary {index}") for index in range(over_cap)
+ assert result == {
+ "experiment": {
+ "id": 7,
+ "name": "Results test",
+ "status": "running",
+ "start_date": start_date.isoformat(),
+ "end_date": None,
+ "feature_flag_key": "flag-results",
+ },
+ "metrics": [
+ {
+ "uuid": "uuid-1",
+ "name": "Mean metric",
+ "metric": {"metric_type": "mean"},
+ "result": {"baseline": {"key": "control"}},
+ "error": None,
+ }
],
- )
-
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
-
- assert result["totalMetricsCount"] == over_cap
- assert result["totalSecondaryMetricsCount"] == over_cap
- assert len(result["metrics"]) == MAX_EXPERIMENT_RESULTS_WIDGET_METRICS
- assert len(result["secondaryMetrics"]) == MAX_EXPERIMENT_RESULTS_WIDGET_METRICS
- # The cap is per-section, so a fully-loaded widget runs at most 2x the constant.
- assert mock_runner_cls.return_value.run.call_count == 2 * MAX_EXPERIMENT_RESULTS_WIDGET_METRICS
-
- @patch("products.dashboards.backend.widgets.experiment_results.ExperimentQueryRunner")
- def test_computes_a_shared_metric_with_its_link_overrides(self, mock_runner_cls: MagicMock) -> None:
- mock_runner_cls.return_value.run.return_value = MagicMock(model_dump=lambda mode="json": {})
- experiment = self._create_experiment(start_date=timezone.now())
- saved_metric = ExperimentSavedMetric.objects.create(
- team=self.team, name="Shared metric", query=_experiment_metric("shared-1", "")
- )
- ExperimentToSavedMetric.objects.create(
- experiment=experiment,
- saved_metric=saved_metric,
- metadata={"type": "primary", "breakdowns": [{"property": "$browser", "type": "event"}]},
- )
-
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
-
- assert [entry["name"] for entry in result["metrics"]] == ["Shared metric"]
- calculated_metric = mock_runner_cls.call_args.kwargs["query"].metric
- assert [breakdown.property for breakdown in calculated_metric.breakdownFilter.breakdowns] == ["$browser"]
+ "secondaryMetrics": [
+ {
+ "uuid": "secondary-1",
+ "name": "Broken metric",
+ "metric": None,
+ "result": None,
+ "error": "Could not compute.",
+ }
+ ],
+ **({"totalMetricsCount": 4, "totalSecondaryMetricsCount": 1} if include_total_count else {}),
+ }
def test_legacy_metric_reports_unsupported_error(self) -> None:
- experiment = self._create_experiment(
+ experiment_id = self._create_experiment(
start_date=timezone.now(),
metrics=[{"kind": "ExperimentTrendsQuery", "uuid": "uuid-legacy", "name": "Legacy"}],
)
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
+ result = run_experiment_results_widget(self.team, {"experimentId": experiment_id}, user=self.user)
entry = result["metrics"][0]
assert entry["error"] == "Legacy metrics are not supported in this widget."
assert entry["result"] is None
- @parameterized.expand(
- [
- ("primary", "metrics"),
- ("secondary", "secondaryMetrics"),
- ]
- )
- @patch("products.dashboards.backend.widgets.experiment_results.ExperimentQueryRunner")
- def test_metric_failure_is_isolated_and_sanitized(
- self, _label: str, result_key: str, mock_runner_cls: MagicMock
- ) -> None:
- mock_runner_cls.return_value.run.side_effect = Exception("SELECT * FROM secret_table")
- broken = [_experiment_metric("uuid-1", "Broken metric")]
- is_primary = result_key == "metrics"
- experiment = self._create_experiment(
- start_date=timezone.now(),
- metrics=broken if is_primary else None,
- metrics_secondary=None if is_primary else broken,
- )
-
- result = run_experiment_results_widget(self.team, {"experimentId": experiment.id}, user=self.user)
-
- entry = result[result_key][0]
- assert entry["error"] == "Could not compute results for this metric."
- assert "secret_table" not in str(entry)
-
class _InlineExecutor:
"""Runs run_widgets work items on the test thread so widget queries can see
@@ -490,8 +375,11 @@ class TestExperimentWidgetsViaRunWidgetsEndpoint(APIBaseTest):
def test_runs_experiments_list_widget_tile(self) -> None:
feature_flag = FeatureFlag.objects.create(team=self.team, key="endpoint-flag", created_by=self.user)
- Experiment.objects.create(
- team=self.team, name="Endpoint experiment", feature_flag=feature_flag, created_by=self.user
+ create_experiment(
+ team_id=self.team.id,
+ name="Endpoint experiment",
+ feature_flag_id=feature_flag.id,
+ created_by_id=self.user.id,
)
dashboard_id, _ = self.dashboard_api.create_dashboard({"name": "dash"})
_, dashboard_json = self.dashboard_api.create_widget_tile(
diff --git a/products/dashboards/backend/widgets/experiment_results.py b/products/dashboards/backend/widgets/experiment_results.py
index c2247bed6b45..482c4a9157d9 100644
--- a/products/dashboards/backend/widgets/experiment_results.py
+++ b/products/dashboards/backend/widgets/experiment_results.py
@@ -1,133 +1,21 @@
from __future__ import annotations
-import logging
+from dataclasses import asdict
from typing import Any
-from pydantic import BaseModel
-
-from posthog.schema import (
- ExperimentFunnelMetric,
- ExperimentMeanMetric,
- ExperimentQuery,
- ExperimentRatioMetric,
- ExperimentRetentionMetric,
-)
-
-from posthog.clickhouse.query_tagging import Feature, Product, tags_context
-from posthog.hogql_queries.query_runner import ExecutionMode
from posthog.models.team import Team
from posthog.models.user import User
from products.access_control.backend.facade.user_access_control import UserAccessControl
from products.dashboards.backend.widget_specs.configs import EXPERIMENT_RESULTS_WIDGET_TYPE
from products.dashboards.backend.widget_specs.registry import validate_widget_config
-from products.experiments.backend.hogql_queries.experiment_query_runner import ExperimentQueryRunner
-from products.experiments.backend.models.experiment import Experiment, metric_display_rank
-
-logger = logging.getLogger(__name__)
+from products.experiments.backend.facade.dashboard_widgets import experiment_results_widget, has_accessible_experiments
# Cap on metrics computed per section (primary, secondary) so one widget can't fan out into many
# ClickHouse queries. Applied independently to each section, so a fully-loaded widget runs at most
# 2x this many queries.
MAX_EXPERIMENT_RESULTS_WIDGET_METRICS = 3
-_METRIC_BUILDERS: dict[str, type[BaseModel]] = {
- "mean": ExperimentMeanMetric,
- "funnel": ExperimentFunnelMetric,
- "ratio": ExperimentRatioMetric,
- "retention": ExperimentRetentionMetric,
-}
-
-
-def _serialize_experiment_summary(experiment: Experiment) -> dict[str, Any]:
- return {
- "id": experiment.id,
- "name": experiment.name,
- "status": experiment.status_label,
- "start_date": experiment.start_date.isoformat() if experiment.start_date else None,
- "end_date": experiment.end_date.isoformat() if experiment.end_date else None,
- "feature_flag_key": experiment.feature_flag.key,
- }
-
-
-def _sort_by_ordered_uuids(metric_dicts: list[dict[str, Any]], ordered_uuids: list[str] | None) -> None:
- if not ordered_uuids:
- return
- rank = metric_display_rank(ordered_uuids)
- metric_dicts.sort(key=lambda metric: rank(metric.get("uuid", "")))
-
-
-def _collect_metric_dicts(experiment: Experiment) -> tuple[list[dict[str, Any]], list[dict[str, Any]]]:
- """Inline metrics plus saved metrics, partitioned into (primary, secondary) in display order when known.
-
- The saved-metric link set is read once and split here so a widget render issues a single query for it.
- """
- from products.experiments.backend.facade.timeseries import ( # noqa: PLC0415 — circular import
- apply_saved_metric_overrides,
- )
-
- primary: list[dict[str, Any]] = [dict(metric) for metric in (experiment.metrics or [])]
- secondary: list[dict[str, Any]] = [dict(metric) for metric in (experiment.metrics_secondary or [])]
-
- for link in experiment.experimenttosavedmetric_set.select_related("saved_metric").all():
- saved_query = link.saved_metric.query
- if not saved_query:
- continue
- metric_dict = {
- **apply_saved_metric_overrides(saved_query, link.metadata),
- "name": saved_query.get("name") or link.saved_metric.name,
- }
- # Links default to primary when untyped; an unrecognized type belongs to neither section.
- role = (link.metadata or {}).get("type", "primary")
- if role == "secondary":
- secondary.append(metric_dict)
- elif role == "primary":
- primary.append(metric_dict)
-
- _sort_by_ordered_uuids(primary, experiment.primary_metrics_ordered_uuids)
- _sort_by_ordered_uuids(secondary, experiment.secondary_metrics_ordered_uuids)
-
- return primary, secondary
-
-
-def _compute_metric_entry(
- team: Team, experiment: Experiment, metric_dict: dict[str, Any], index: int
-) -> dict[str, Any]:
- entry: dict[str, Any] = {
- "uuid": metric_dict.get("uuid"),
- "name": metric_dict.get("name") or f"Metric {index + 1}",
- "metric": None,
- "result": None,
- "error": None,
- }
-
- metric_builder = _METRIC_BUILDERS.get(metric_dict.get("metric_type", ""))
- if metric_dict.get("kind") != "ExperimentMetric" or metric_builder is None:
- entry["error"] = "Legacy metrics are not supported in this widget."
- return entry
-
- try:
- metric = metric_builder.model_validate(metric_dict)
- runner = ExperimentQueryRunner(
- query=ExperimentQuery(experiment_id=experiment.id, metric=metric),
- team=team,
- )
- response = runner.run(execution_mode=ExecutionMode.RECENT_CACHE_CALCULATE_BLOCKING_IF_STALE)
- result_dict = response.model_dump(mode="json")
- entry["metric"] = metric.model_dump(mode="json")
- # Strip per-variant session payloads and debug SQL — the widget only renders the scorecard.
- for key in ("clickhouse_sql", "hogql", "insight", "query_status"):
- result_dict.pop(key, None)
- entry["result"] = result_dict
- except Exception:
- logger.exception(
- "experiment_results_widget_metric_failed",
- extra={"experiment_id": experiment.id, "metric_uuid": metric_dict.get("uuid")},
- )
- entry["error"] = "Could not compute results for this metric."
-
- return entry
-
def run_experiment_results_widget(
team: Team,
@@ -144,39 +32,39 @@ def run_experiment_results_widget(
access_control = UserAccessControl(user=user, team=team) if user is not None else None
if experiment_id is None:
- accessible = Experiment.objects.filter(team=team, deleted=False)
- if access_control is not None:
- accessible = access_control.filter_queryset_by_access_level(accessible)
- return {"experiment": None, "metrics": [], "needsConfiguration": True, "hasExperiments": accessible.exists()}
+ return {
+ "experiment": None,
+ "metrics": [],
+ "needsConfiguration": True,
+ "hasExperiments": has_accessible_experiments(team, access_control),
+ }
- experiment_queryset = Experiment.objects.filter(id=experiment_id, team=team, deleted=False).select_related(
- "feature_flag"
+ experiment = experiment_results_widget(
+ team, access_control, experiment_id=experiment_id, max_metrics_per_section=MAX_EXPERIMENT_RESULTS_WIDGET_METRICS
)
- if access_control is not None:
- experiment_queryset = access_control.filter_queryset_by_access_level(experiment_queryset)
- experiment = experiment_queryset.first()
if experiment is None:
return {"experiment": None, "metrics": [], "experimentNotFound": True}
payload: dict[str, Any] = {
- "experiment": _serialize_experiment_summary(experiment),
+ "experiment": {
+ "id": experiment.id,
+ "name": experiment.name,
+ "status": experiment.status,
+ "start_date": experiment.start_date.isoformat() if experiment.start_date else None,
+ "end_date": experiment.end_date.isoformat() if experiment.end_date else None,
+ "feature_flag_key": experiment.feature_flag_key,
+ },
"metrics": [],
"secondaryMetrics": [],
}
- if experiment.start_date is None:
- # Draft experiments have no exposure data yet — nothing to compute.
+ if experiment.metrics is None:
return payload
- primary_metric_dicts, secondary_metric_dicts = _collect_metric_dicts(experiment)
if include_total_count:
- payload["totalMetricsCount"] = len(primary_metric_dicts)
- payload["totalSecondaryMetricsCount"] = len(secondary_metric_dicts)
-
- with tags_context(product=Product.EXPERIMENTS, feature=Feature.QUERY, team_id=team.pk):
- for index, metric_dict in enumerate(primary_metric_dicts[:MAX_EXPERIMENT_RESULTS_WIDGET_METRICS]):
- payload["metrics"].append(_compute_metric_entry(team, experiment, metric_dict, index))
- for index, metric_dict in enumerate(secondary_metric_dicts[:MAX_EXPERIMENT_RESULTS_WIDGET_METRICS]):
- payload["secondaryMetrics"].append(_compute_metric_entry(team, experiment, metric_dict, index))
+ payload["totalMetricsCount"] = experiment.metrics.primary_total
+ payload["totalSecondaryMetricsCount"] = experiment.metrics.secondary_total
+ payload["metrics"] = [asdict(metric) for metric in experiment.metrics.primary]
+ payload["secondaryMetrics"] = [asdict(metric) for metric in experiment.metrics.secondary]
return payload
diff --git a/products/dashboards/backend/widgets/experiments_list.py b/products/dashboards/backend/widgets/experiments_list.py
index c8f6980a9c04..9b4b2a048a31 100644
--- a/products/dashboards/backend/widgets/experiments_list.py
+++ b/products/dashboards/backend/widgets/experiments_list.py
@@ -10,22 +10,23 @@ from products.dashboards.backend.constants import MAX_WIDGET_RESULT_LIMIT
from products.dashboards.backend.widget_specs.configs import EXPERIMENTS_LIST_WIDGET_TYPE
from products.dashboards.backend.widget_specs.registry import validate_widget_config
from products.dashboards.backend.widgets.list_widget import ListWidgetPage, run_list_widget
-from products.experiments.backend.models.experiment import Experiment
+from products.experiments.backend.facade.contracts import ExperimentListWidgetRow
+from products.experiments.backend.facade.dashboard_widgets import experiments_list_widget_page
ValidatedExperimentsListWidgetConfig = dict[str, Any]
-def _serialize_experiment_row(experiment: Experiment) -> dict[str, Any]:
+def _serialize_experiment_row(experiment: ExperimentListWidgetRow) -> dict[str, Any]:
created_by = experiment.created_by
return {
"id": experiment.id,
"name": experiment.name,
- "status": experiment.status_label,
+ "status": experiment.status,
"conclusion": experiment.conclusion,
"start_date": experiment.start_date.isoformat() if experiment.start_date else None,
"end_date": experiment.end_date.isoformat() if experiment.end_date else None,
- "created_at": experiment.created_at.isoformat() if experiment.created_at else None,
- "feature_flag_key": experiment.feature_flag.key,
+ "created_at": experiment.created_at.isoformat(),
+ "feature_flag_key": experiment.feature_flag_key,
"created_by": (
{
"id": created_by.id,
@@ -45,31 +46,22 @@ def run_experiments_list_widget(
*,
include_total_count: bool = True,
) -> dict[str, Any]:
- # ExperimentService transitively imports the dashboard API, which loads the widget registry,
- # which imports this module — deferring the import breaks that cycle.
- from products.experiments.backend.experiment_service import ExperimentService # noqa: PLC0415
-
typed_config = validate_widget_config(EXPERIMENTS_LIST_WIDGET_TYPE, config)
limit = typed_config["limit"]
-
- order_by = typed_config.get("orderBy", "created_at")
- order_prefix = "-" if typed_config.get("orderDirection", "DESC") == "DESC" else ""
- query_params: dict[str, Any] = {"status": typed_config["status"], "order": f"{order_prefix}{order_by}"}
- created_by = typed_config.get("createdBy")
- if created_by is not None:
- query_params["created_by_id"] = created_by
-
- base_queryset = Experiment.objects.filter(team=team).select_related("created_by", "feature_flag")
- service = ExperimentService(team=team, user=user)
- queryset = service.filter_experiments_queryset(base_queryset, action="list", query_params=query_params)
-
- if user is not None:
- # Honor object-level experiment access controls, matching the REST list endpoint.
- queryset = UserAccessControl(user=user, team=team).filter_queryset_by_access_level(queryset)
+ # One instance serves both page fetches, so the access-control rows load once.
+ access = UserAccessControl(user=user, team=team) if user is not None else None
def fetch_page(page_limit: int) -> ListWidgetPage:
- rows = list(queryset[: page_limit + 1])
- return ListWidgetPage(results=rows[:page_limit], has_more=len(rows) > page_limit, next_offset=page_limit)
+ page = experiments_list_widget_page(
+ team,
+ access,
+ status=typed_config["status"],
+ order_by=typed_config.get("orderBy", "created_at"),
+ descending=typed_config.get("orderDirection", "DESC") == "DESC",
+ created_by_id=typed_config.get("createdBy"),
+ limit=page_limit,
+ )
+ return ListWidgetPage(results=list(page.rows), has_more=page.has_more, next_offset=page_limit)
return run_list_widget(
limit=limit,
diff --git a/products/experiments/backend/dashboard_widgets.py b/products/experiments/backend/dashboard_widgets.py
new file mode 100644
index 000000000000..1093c82e7bca
--- /dev/null
+++ b/products/experiments/backend/dashboard_widgets.py
@@ -0,0 +1,161 @@
+"""The experiments reads behind the dashboard experiment widgets. Dashboards calls them through
+`facade/dashboard_widgets.py`."""
+
+import logging
+from typing import Any
+
+from django.db.models import QuerySet
+
+from posthog.schema import ExperimentQuery
+
+from posthog.clickhouse.query_tagging import Feature, Product, tags_context
+from posthog.dataclasses import frozen
+from posthog.hogql_queries.query_runner import ExecutionMode
+from posthog.models.team import Team
+
+from products.access_control.backend.facade.user_access_control import UserAccessControl
+from products.experiments.backend.facade.contracts import ExperimentResultsWidgetMetric, ExperimentResultsWidgetMetrics
+from products.experiments.backend.hogql_queries.experiment_query_runner import ExperimentQueryRunner
+from products.experiments.backend.metric_resolution import METRIC_BUILDERS, apply_saved_metric_overrides
+from products.experiments.backend.models.experiment import Experiment, metric_display_rank
+
+logger = logging.getLogger(__name__)
+
+
+def _visible_to(access: UserAccessControl | None, queryset: QuerySet[Experiment]) -> QuerySet[Experiment]:
+ return queryset if access is None else access.filter_queryset_by_access_level(queryset)
+
+
+def list_widget_queryset(
+ team: Team,
+ access: UserAccessControl | None,
+ *,
+ status: str,
+ order_by: str,
+ descending: bool,
+ created_by_id: int | None,
+) -> QuerySet[Experiment]:
+ # ExperimentService transitively imports the dashboard API, which loads the widget registry, which imports the
+ # dashboard widgets that import this module. Deferring the import breaks that cycle.
+ from products.experiments.backend.experiment_service import ExperimentService # noqa: PLC0415
+
+ order_prefix = "-" if descending else ""
+ query_params: dict[str, Any] = {"status": status, "order": f"{order_prefix}{order_by}"}
+ if created_by_id is not None:
+ query_params["created_by_id"] = created_by_id
+
+ base_queryset = Experiment.objects.filter(team=team).select_related("created_by", "feature_flag")
+ service = ExperimentService(team=team, user=access.user if access is not None else None)
+ queryset = service.filter_experiments_queryset(base_queryset, action="list", query_params=query_params)
+ # Honor object-level experiment access controls, matching the REST list endpoint.
+ return _visible_to(access, queryset)
+
+
+def has_accessible_experiments(team: Team, access: UserAccessControl | None) -> bool:
+ return _visible_to(access, Experiment.objects.filter(team=team, deleted=False)).exists()
+
+
+def accessible_experiment(team: Team, access: UserAccessControl | None, experiment_id: int) -> Experiment | None:
+ # Honor object-level experiment access controls, matching the REST endpoint. A user denied
+ # access to a specific experiment must not see it (or its results) through the widget.
+ queryset = Experiment.objects.filter(id=experiment_id, team=team, deleted=False).select_related("feature_flag")
+ return _visible_to(access, queryset).first()
+
+
+def _sort_by_ordered_uuids(metric_dicts: list[dict[str, Any]], ordered_uuids: list[str] | None) -> None:
+ if not ordered_uuids:
+ return
+ rank = metric_display_rank(ordered_uuids)
+ metric_dicts.sort(key=lambda metric: rank(metric.get("uuid", "")))
+
+
+@frozen
+class _MetricDicts:
+ primary: list[dict[str, Any]]
+ secondary: list[dict[str, Any]]
+
+
+def _collect_metric_dicts(experiment: Experiment) -> _MetricDicts:
+ """Inline metrics plus saved metrics, partitioned into primary and secondary in display order when known.
+
+ The saved-metric link set is read once and split here so a widget render issues a single query for it.
+ """
+ primary: list[dict[str, Any]] = [dict(metric) for metric in (experiment.metrics or [])]
+ secondary: list[dict[str, Any]] = [dict(metric) for metric in (experiment.metrics_secondary or [])]
+
+ for link in experiment.experimenttosavedmetric_set.select_related("saved_metric").all():
+ saved_query = link.saved_metric.query
+ if not saved_query:
+ continue
+ metric_dict = {
+ **apply_saved_metric_overrides(saved_query, link.metadata),
+ "name": saved_query.get("name") or link.saved_metric.name,
+ }
+ # Links default to primary when untyped; an unrecognized type belongs to neither section.
+ role = (link.metadata or {}).get("type", "primary")
+ if role == "secondary":
+ secondary.append(metric_dict)
+ elif role == "primary":
+ primary.append(metric_dict)
+
+ _sort_by_ordered_uuids(primary, experiment.primary_metrics_ordered_uuids)
+ _sort_by_ordered_uuids(secondary, experiment.secondary_metrics_ordered_uuids)
+
+ return _MetricDicts(primary=primary, secondary=secondary)
+
+
+def _compute_metric(
+ team: Team, experiment: Experiment, metric_dict: dict[str, Any], index: int
+) -> ExperimentResultsWidgetMetric:
+ uuid = metric_dict.get("uuid")
+ name = metric_dict.get("name") or f"Metric {index + 1}"
+
+ metric_builder = METRIC_BUILDERS.get(metric_dict.get("metric_type", ""))
+ if metric_dict.get("kind") != "ExperimentMetric" or metric_builder is None:
+ return ExperimentResultsWidgetMetric(
+ uuid=uuid, name=name, metric=None, result=None, error="Legacy metrics are not supported in this widget."
+ )
+
+ try:
+ metric = metric_builder.model_validate(metric_dict)
+ runner = ExperimentQueryRunner(
+ query=ExperimentQuery(experiment_id=experiment.id, metric=metric),
+ team=team,
+ )
+ response = runner.run(execution_mode=ExecutionMode.RECENT_CACHE_CALCULATE_BLOCKING_IF_STALE)
+ result_dict = response.model_dump(mode="json")
+ # Strip per-variant session payloads and debug SQL — the widget only renders the scorecard.
+ for key in ("clickhouse_sql", "hogql", "insight", "query_status"):
+ result_dict.pop(key, None)
+ return ExperimentResultsWidgetMetric(
+ uuid=uuid, name=name, metric=metric.model_dump(mode="json"), result=result_dict, error=None
+ )
+ except Exception:
+ logger.exception(
+ "experiment_results_widget_metric_failed",
+ extra={"experiment_id": experiment.id, "metric_uuid": uuid},
+ )
+ return ExperimentResultsWidgetMetric(
+ uuid=uuid, name=name, metric=None, result=None, error="Could not compute results for this metric."
+ )
+
+
+def compute_metrics(
+ team: Team, experiment: Experiment, *, max_metrics_per_section: int
+) -> ExperimentResultsWidgetMetrics:
+ metric_dicts = _collect_metric_dicts(experiment)
+ with tags_context(product=Product.EXPERIMENTS, feature=Feature.QUERY, team_id=team.pk):
+ primary = tuple(
+ _compute_metric(team, experiment, metric_dict, index)
+ for index, metric_dict in enumerate(metric_dicts.primary[:max_metrics_per_section])
+ )
+ secondary = tuple(
+ _compute_metric(team, experiment, metric_dict, index)
+ for index, metric_dict in enumerate(metric_dicts.secondary[:max_metrics_per_section])
+ )
+ return ExperimentResultsWidgetMetrics(
+ primary=primary,
+ secondary=secondary,
+ primary_total=len(metric_dicts.primary),
+ secondary_total=len(metric_dicts.secondary),
+ )
diff --git a/products/experiments/backend/facade/contracts.py b/products/experiments/backend/facade/contracts.py
index ac52a86933b6..64decbba16d7 100644
--- a/products/experiments/backend/facade/contracts.py
+++ b/products/experiments/backend/facade/contracts.py
@@ -83,6 +83,47 @@ class ExperimentSummaryData:
omitted_metric_count: int
+@frozen
+class ExperimentResultsWidgetMetric:
+ """One metric of the dashboard experiment results widget."""
+
+ uuid: str | None
+ name: str
+ # The metric that the query ran, as JSON. None when the metric has no result.
+ metric: dict[str, Any] | None
+ # The query response as JSON, without the SQL and the per-variant session payloads.
+ result: dict[str, Any] | None
+ # A message that is safe to show to the viewer. None when the metric has a result.
+ error: str | None
+
+
+@frozen
+class ExperimentResultsWidgetMetrics:
+ """The metrics of a launched experiment, per section, in display order."""
+
+ primary: tuple[ExperimentResultsWidgetMetric, ...]
+ secondary: tuple[ExperimentResultsWidgetMetric, ...]
+ # The metric count of each section. Only the first metrics of a section run, so a total can be larger than the
+ # metrics above.
+ primary_total: int
+ secondary_total: int
+
+
+@frozen
+class ExperimentResultsWidget:
+ """One experiment, as the dashboard experiment results widget shows it."""
+
+ id: int
+ name: str
+ # Public status string: draft, running, paused, exposure_frozen, or stopped.
+ status: str
+ start_date: datetime | None
+ end_date: datetime | None
+ feature_flag_key: str
+ # None for a draft, which has no exposures to compute results from.
+ metrics: ExperimentResultsWidgetMetrics | None
+
+
@frozen
class TargetableExperiment:
"""A launched experiment whose exposed sessions a replay surface can narrow to."""
@@ -481,6 +522,29 @@ class ExperimentActionReference:
created_by: ExperimentCreator | None
+@frozen
+class ExperimentListWidgetRow:
+ """One experiment in the dashboard experiments list widget."""
+
+ id: int
+ name: str
+ # Public status string: draft, running, paused, exposure_frozen, or stopped.
+ status: str
+ conclusion: str | None
+ start_date: datetime | None
+ end_date: datetime | None
+ created_at: datetime
+ feature_flag_key: str
+ created_by: ExperimentCreator | None
+
+
+@frozen
+class ExperimentListWidgetPage:
+ rows: tuple[ExperimentListWidgetRow, ...]
+ # True when more experiments match than the page holds.
+ has_more: bool
+
+
@dataclass(frozen=True)
class Experiment:
"""Experiment output."""
diff --git a/products/experiments/backend/facade/dashboard_widgets.py b/products/experiments/backend/facade/dashboard_widgets.py
new file mode 100644
index 000000000000..5baa119b7e0b
--- /dev/null
+++ b/products/experiments/backend/facade/dashboard_widgets.py
@@ -0,0 +1,93 @@
+"""Experiments reads for the dashboard experiment widgets.
+
+Each function takes the viewer's access control, or None outside request context, and leaves out the experiments
+that the viewer cannot see, the same as the experiments API.
+"""
+
+from posthog.models.team import Team
+
+from products.access_control.backend.facade.user_access_control import UserAccessControl
+from products.experiments.backend import dashboard_widgets
+from products.experiments.backend.experiment_creator import to_experiment_creator
+from products.experiments.backend.facade.contracts import (
+ ExperimentListWidgetPage,
+ ExperimentListWidgetRow,
+ ExperimentResultsWidget,
+)
+from products.experiments.backend.models.experiment import Experiment
+
+__all__ = [
+ "experiment_results_widget",
+ "experiments_list_widget_page",
+ "has_accessible_experiments",
+]
+
+
+def _list_widget_row(experiment: Experiment) -> ExperimentListWidgetRow:
+ return ExperimentListWidgetRow(
+ id=experiment.id,
+ name=experiment.name,
+ status=experiment.status_label,
+ conclusion=experiment.conclusion,
+ start_date=experiment.start_date,
+ end_date=experiment.end_date,
+ created_at=experiment.created_at,
+ feature_flag_key=experiment.feature_flag.key,
+ created_by=to_experiment_creator(experiment.created_by) if experiment.created_by else None,
+ )
+
+
+def experiments_list_widget_page(
+ team: Team,
+ access: UserAccessControl | None,
+ *,
+ status: str,
+ order_by: str,
+ descending: bool,
+ created_by_id: int | None,
+ limit: int,
+) -> ExperimentListWidgetPage:
+ """The first `limit` experiments that the experiments list shows for these filters and this order.
+
+ `status` and `order_by` take the values of the experiments list API.
+ """
+ queryset = dashboard_widgets.list_widget_queryset(
+ team, access, status=status, order_by=order_by, descending=descending, created_by_id=created_by_id
+ )
+ experiments = list(queryset[: limit + 1])
+ return ExperimentListWidgetPage(
+ rows=tuple(_list_widget_row(experiment) for experiment in experiments[:limit]),
+ has_more=len(experiments) > limit,
+ )
+
+
+def has_accessible_experiments(team: Team, access: UserAccessControl | None) -> bool:
+ """True when the team has an experiment that is not deleted and that the viewer can see."""
+ return dashboard_widgets.has_accessible_experiments(team, access)
+
+
+def experiment_results_widget(
+ team: Team, access: UserAccessControl | None, *, experiment_id: int, max_metrics_per_section: int
+) -> ExperimentResultsWidget | None:
+ """The experiment with the results of its first `max_metrics_per_section` primary and secondary metrics.
+
+ Each metric runs an experiment query, from the cache when it is recent. None when the experiment does not exist,
+ is deleted, belongs to another team, or the viewer cannot see it.
+ """
+ experiment = dashboard_widgets.accessible_experiment(team, access, experiment_id)
+ if experiment is None:
+ return None
+
+ return ExperimentResultsWidget(
+ id=experiment.id,
+ name=experiment.name,
+ status=experiment.status_label,
+ start_date=experiment.start_date,
+ end_date=experiment.end_date,
+ feature_flag_key=experiment.feature_flag.key,
+ metrics=(
+ None
+ if experiment.start_date is None
+ else dashboard_widgets.compute_metrics(team, experiment, max_metrics_per_section=max_metrics_per_section)
+ ),
+ )
diff --git a/products/experiments/backend/test/test_facade_dashboard_widgets.py b/products/experiments/backend/test/test_facade_dashboard_widgets.py
new file mode 100644
index 000000000000..75722795bc86
--- /dev/null
+++ b/products/experiments/backend/test/test_facade_dashboard_widgets.py
@@ -0,0 +1,266 @@
+from datetime import datetime
+from typing import Any
+
+from posthog.test.base import BaseTest
+from unittest.mock import MagicMock, patch
+
+from django.utils import timezone
+
+from parameterized import parameterized
+
+from posthog.constants import AvailableFeature
+from posthog.models import OrganizationMembership, Team, User
+
+from products.access_control.backend.facade.testing import create_access_control
+from products.access_control.backend.facade.user_access_control import UserAccessControl
+from products.experiments.backend.facade.dashboard_widgets import (
+ experiment_results_widget,
+ experiments_list_widget_page,
+ has_accessible_experiments,
+)
+from products.experiments.backend.models.experiment import (
+ EXPOSURE_FROZEN_GROUP_KEY,
+ Experiment,
+ ExperimentSavedMetric,
+ ExperimentToSavedMetric,
+)
+from products.feature_flags.backend.models.feature_flag import FeatureFlag
+
+RUNNER = "products.experiments.backend.dashboard_widgets.ExperimentQueryRunner"
+MAX_METRICS = 3
+
+
+def _metric(uuid: str, name: str) -> dict[str, Any]:
+ return {
+ "kind": "ExperimentMetric",
+ "metric_type": "mean",
+ "uuid": uuid,
+ "name": name,
+ "source": {"kind": "EventsNode", "event": "$pageview"},
+ }
+
+
+class TestDashboardWidgetsFacade(BaseTest):
+ def _experiment(
+ self,
+ name: str,
+ *,
+ team: Team | None = None,
+ start_date: datetime | None = None,
+ end_date: datetime | None = None,
+ flag_active: bool = True,
+ exposure_frozen: bool = False,
+ **fields: Any,
+ ) -> Experiment:
+ team = team or self.team
+ flag = FeatureFlag.objects.create(
+ team=team,
+ key=f"flag-{name}",
+ created_by=self.user,
+ active=flag_active,
+ filters=(
+ {"groups": [{"properties": [], "rollout_percentage": 100, EXPOSURE_FROZEN_GROUP_KEY: True}]}
+ if exposure_frozen
+ else {}
+ ),
+ )
+ return Experiment.objects.create(
+ team=team,
+ name=name,
+ feature_flag=flag,
+ created_by=self.user,
+ start_date=start_date,
+ end_date=end_date,
+ **fields,
+ )
+
+ def _member_blocked_from(self, experiment: Experiment) -> UserAccessControl:
+ self.organization.available_product_features = [
+ {"key": AvailableFeature.ACCESS_CONTROL, "name": "Access control"}
+ ]
+ self.organization.save()
+ member = User.objects.create_and_join(self.organization, "[email protected]", "pw")
+ create_access_control(
+ team_id=self.team.id,
+ resource="experiment",
+ resource_id=str(experiment.id),
+ access_level="none",
+ organization_member_id=OrganizationMembership.objects.get(user=member).id,
+ )
+ return UserAccessControl(user=member, team=self.team)
+
+ def _list_names(
+ self, access: UserAccessControl | None = None, *, status: str = "all", limit: int = 10
+ ) -> list[str]:
+ page = experiments_list_widget_page(
+ self.team, access, status=status, order_by="name", descending=False, created_by_id=None, limit=limit
+ )
+ return [row.name for row in page.rows]
+
+ def test_list_leaves_out_other_teams_deleted_and_inaccessible_experiments(self) -> None:
+ self._experiment("Visible")
+ self._experiment("Deleted", deleted=True)
+ self._experiment("Other team", team=Team.objects.create(organization=self.organization, name="other"))
+ member_access = self._member_blocked_from(self._experiment("Blocked"))
+
+ assert self._list_names() == ["Blocked", "Visible"]
+ assert self._list_names(member_access) == ["Visible"]
+
+ @parameterized.expand([("running", "Running"), ("paused", "Paused"), ("exposure_frozen", "Frozen")])
+ def test_list_filters_by_status(self, status: str, expected_name: str) -> None:
+ now = timezone.now()
+ self._experiment("Running", start_date=now)
+ self._experiment("Paused", start_date=now, flag_active=False)
+ self._experiment("Frozen", start_date=now, exposure_frozen=True)
+
+ assert self._list_names(status=status) == [expected_name]
+
+ def test_list_page_keeps_the_order_and_reports_more_rows(self) -> None:
+ for name in ("B", "C", "A"):
+ self._experiment(name)
+
+ page = experiments_list_widget_page(
+ self.team, None, status="all", order_by="name", descending=True, created_by_id=None, limit=2
+ )
+
+ assert [row.name for row in page.rows] == ["C", "B"]
+ assert page.has_more is True
+ assert self._list_names(limit=3) == ["A", "B", "C"]
+
+ def test_has_accessible_experiments_leaves_out_other_teams_deleted_and_inaccessible_experiments(self) -> None:
+ self._experiment("Deleted", deleted=True)
+ self._experiment("Other team", team=Team.objects.create(organization=self.organization, name="other"))
+ assert has_accessible_experiments(self.team, None) is False
+
+ member_access = self._member_blocked_from(self._experiment("Blocked"))
+ assert has_accessible_experiments(self.team, member_access) is False
+ assert has_accessible_experiments(self.team, None) is True
+
+ def test_results_leave_out_other_teams_deleted_and_inaccessible_experiments(self) -> None:
+ other_team = self._experiment("Other team", team=Team.objects.create(organization=self.organization, name="o"))
+ deleted = self._experiment("Deleted", deleted=True)
+ blocked = self._experiment("Blocked")
+ member_access = self._member_blocked_from(blocked)
+
+ for experiment, access in ((other_team, None), (deleted, None), (blocked, member_access)):
+ assert (
+ experiment_results_widget(
+ self.team, access, experiment_id=experiment.id, max_metrics_per_section=MAX_METRICS
+ )
+ is None
+ )
+ assert (
+ experiment_results_widget(self.team, None, experiment_id=blocked.id, max_metrics_per_section=MAX_METRICS)
+ is not None
+ )
+
+ @patch(RUNNER)
+ def test_results_of_a_draft_run_no_query(self, mock_runner_cls: MagicMock) -> None:
+ experiment = self._experiment("Draft", metrics=[_metric("uuid-1", "Mean metric")])
+
+ widget = experiment_results_widget(
+ self.team, None, experiment_id=experiment.id, max_metrics_per_section=MAX_METRICS
+ )
+
+ assert widget is not None
+ assert widget.status == "draft"
+ assert widget.metrics is None
+ mock_runner_cls.assert_not_called()
+
+ @patch(RUNNER)
+ def test_results_compute_each_section_without_debug_fields(self, mock_runner_cls: MagicMock) -> None:
+ mock_runner_cls.return_value.run.return_value = MagicMock(
+ model_dump=lambda mode="json": {
+ "kind": "NewExperimentQueryResponse",
+ "baseline": {"key": "control", "number_of_samples": 100, "sum": 40, "sum_squares": 30},
+ "variant_results": [{"key": "test", "number_of_samples": 100, "sum": 55, "sum_squares": 40}],
+ "clickhouse_sql": "SELECT secret",
+ }
+ )
+ experiment = self._experiment(
+ "Running",
+ start_date=timezone.now(),
+ metrics=[_metric("uuid-1", "Primary metric")],
+ metrics_secondary=[_metric("secondary-1", "Secondary metric")],
+ )
+
+ widget = experiment_results_widget(
+ self.team, None, experiment_id=experiment.id, max_metrics_per_section=MAX_METRICS
+ )
+
+ assert widget is not None and widget.metrics is not None
+ assert widget.status == "running"
+ assert [metric.name for metric in widget.metrics.primary] == ["Primary metric"]
+ assert [metric.name for metric in widget.metrics.secondary] == ["Secondary metric"]
+ assert (widget.metrics.primary_total, widget.metrics.secondary_total) == (1, 1)
+ for metric in (*widget.metrics.primary, *widget.metrics.secondary):
+ assert metric.error is None
+ assert metric.metric is not None and metric.metric["metric_type"] == "mean"
+ assert metric.result is not None and metric.result["baseline"]["key"] == "control"
+ assert "clickhouse_sql" not in metric.result
+ assert mock_runner_cls.call_args.kwargs["query"].experiment_id == experiment.id
+
+ @patch(RUNNER)
+ def test_results_cap_each_section_independently(self, mock_runner_cls: MagicMock) -> None:
+ mock_runner_cls.return_value.run.return_value = MagicMock(model_dump=lambda mode="json": {})
+ over_cap = MAX_METRICS + 2
+ experiment = self._experiment(
+ "Running",
+ start_date=timezone.now(),
+ metrics=[_metric(f"uuid-{index}", f"Metric {index}") for index in range(over_cap)],
+ metrics_secondary=[_metric(f"secondary-{index}", f"Secondary {index}") for index in range(over_cap)],
+ )
+
+ widget = experiment_results_widget(
+ self.team, None, experiment_id=experiment.id, max_metrics_per_section=MAX_METRICS
+ )
+
+ assert widget is not None and widget.metrics is not None
+ assert (widget.metrics.primary_total, widget.metrics.secondary_total) == (over_cap, over_cap)
+ assert (len(widget.metrics.primary), len(widget.metrics.secondary)) == (MAX_METRICS, MAX_METRICS)
+ assert mock_runner_cls.return_value.run.call_count == 2 * MAX_METRICS
+
+ @patch(RUNNER)
+ def test_results_compute_a_shared_metric_with_its_link_overrides(self, mock_runner_cls: MagicMock) -> None:
+ mock_runner_cls.return_value.run.return_value = MagicMock(model_dump=lambda mode="json": {})
+ experiment = self._experiment("Running", start_date=timezone.now())
+ saved_metric = ExperimentSavedMetric.objects.create(
+ team=self.team, name="Shared metric", query=_metric("shared-1", "")
+ )
+ ExperimentToSavedMetric.objects.create(
+ experiment=experiment,
+ saved_metric=saved_metric,
+ metadata={"type": "primary", "breakdowns": [{"property": "$browser", "type": "event"}]},
+ )
+
+ widget = experiment_results_widget(
+ self.team, None, experiment_id=experiment.id, max_metrics_per_section=MAX_METRICS
+ )
+
+ assert widget is not None and widget.metrics is not None
+ assert [metric.name for metric in widget.metrics.primary] == ["Shared metric"]
+ calculated_metric = mock_runner_cls.call_args.kwargs["query"].metric
+ assert [breakdown.property for breakdown in calculated_metric.breakdownFilter.breakdowns] == ["$browser"]
+
+ @parameterized.expand([("primary", True), ("secondary", False)])
+ @patch(RUNNER)
+ def test_results_isolate_and_sanitize_a_metric_failure(
+ self, _label: str, is_primary: bool, mock_runner_cls: MagicMock
+ ) -> None:
+ mock_runner_cls.return_value.run.side_effect = Exception("SELECT * FROM secret_table")
+ broken = [_metric("uuid-1", "Broken metric")]
+ experiment = self._experiment(
+ "Running",
+ start_date=timezone.now(),
+ metrics=broken if is_primary else [],
+ metrics_secondary=[] if is_primary else broken,
+ )
+
+ widget = experiment_results_widget(
+ self.team, None, experiment_id=experiment.id, max_metrics_per_section=MAX_METRICS
+ )
+
+ assert widget is not None and widget.metrics is not None
+ (metric,) = widget.metrics.primary or widget.metrics.secondary
+ assert metric.error == "Could not compute results for this metric."
+ assert "secret_table" not in str(metric)