: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
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.pyindex 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 Futurefrom typing import Anyfrom posthog.test.base import APIBaseTest-from unittest.mock import MagicMock, patch+from unittest.mock import patchfrom django.test import SimpleTestCasefrom 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_widgetfrom 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_experimentfrom 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: PLC0415team.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: UseAccessControl.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"] == 1assert result["hasMore"] is Falserow = result["results"][0]- assert row["id"] == experiment.id+ assert row["id"] == experiment_idassert 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 Truedef 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_idassert result["experiment"]["status"] == "draft"assert result["metrics"] == []assert result["secondaryMetrics"] == []assert "totalMetricsCount" not in resultassert "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.pyindex 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 asdictfrom 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 ExecutionModefrom posthog.models.team import Teamfrom posthog.models.user import Userfrom products.access_control.backend.facade.user_access_control import UserAccessControlfrom products.dashboards.backend.widget_specs.configs import EXPERIMENT_RESULTS_WIDGET_TYPEfrom 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 Noneif 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 payloaddiff --git a/products/dashboards/backend/widgets/experiments_list.py b/products/dashboards/backend/widgets/experiments_list.pyindex 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_LIMITfrom products.dashboards.backend.widget_specs.configs import EXPERIMENTS_LIST_WIDGET_TYPEfrom products.dashboards.backend.widget_specs.registry import validate_widget_configfrom 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_pageValidatedExperimentsListWidgetConfig = 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_byreturn {"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 Nonedef 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.pynew file mode 100644index 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.pyindex 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++@frozenclass 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.pynew file mode 100644index 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.pynew file mode 100644index 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)