Skip to content

AutoGPT is the vision of accessible AI for everyone, to use and to build on. Our mission is to provide the tools, so that you can focus on what matters.

fix(backend): remove the morning-briefing cron when the feature flag is off (#14308)

Reinier van der Leer89d5518c9084
diff --git a/autogpt_platform/backend/backend/copilot/briefing/generate.py b/autogpt_platform/backend/backend/copilot/briefing/generate.py
index e555ce889f..b95f3cb6f2 100644
--- a/autogpt_platform/backend/backend/copilot/briefing/generate.py
+++ b/autogpt_platform/backend/backend/copilot/briefing/generate.py
@@ -21,7 +21,7 @@ from backend.data.db_accessors import (
)
from backend.data.execution import ExecutionStatus, GraphExecutionMeta
from backend.util.clients import get_database_manager_async_client
-from backend.util.feature_flag import Flag, is_feature_enabled
+from backend.util.feature_flag import Flag, evaluate_feature_flag, is_feature_enabled
from backend.util.timezone_utils import get_user_timezone_or_utc
from .models import BriefingContent, BriefingDecisionItem, BriefingRunItem
@@ -253,7 +253,15 @@ async def _compose_fresh_briefing(
async def generate_and_deliver_briefing(user_id: str) -> BriefingResult:
- if not await is_feature_enabled(Flag.HIRE_EXPERTS, user_id, default=False):
+ enabled, authoritative = await evaluate_feature_flag(
+ Flag.HIRE_EXPERTS, user_id, default=False
+ )
+ if not enabled:
+ # Only a flag that actually evaluated may unregister the cron (see
+ # ``execute_morning_briefing``). A failed read yields False too, and
+ # would delete every user's schedule on one bad boot or DB blip.
+ if not authoritative:
+ return {"status": "skipped", "reason": "flag_unavailable"}
return {"status": "skipped", "reason": "flag_disabled"}
user = await user_db().get_user_by_id(user_id)
diff --git a/autogpt_platform/backend/backend/copilot/briefing/generate_test.py b/autogpt_platform/backend/backend/copilot/briefing/generate_test.py
index a9167e32e6..78b0b463f6 100644
--- a/autogpt_platform/backend/backend/copilot/briefing/generate_test.py
+++ b/autogpt_platform/backend/backend/copilot/briefing/generate_test.py
@@ -263,13 +263,27 @@ async def test_generate_skips_when_flag_off(monkeypatch):
from backend.copilot.briefing import generate
async def flag_off(*a, **kw):
- return False
+ return False, True
- monkeypatch.setattr(generate, "is_feature_enabled", flag_off)
+ monkeypatch.setattr(generate, "evaluate_feature_flag", flag_off)
result = await generate.generate_and_deliver_briefing("user-1")
assert result == {"status": "skipped", "reason": "flag_disabled"}
+async def test_generate_reports_an_unevaluated_flag_separately(monkeypatch):
+ """A flag read that FAILED yields False, same as a real "off". Only the
+ latter may unregister the cron, so the two must not share a reason."""
+ from backend.copilot.briefing import generate
+
+ async def flag_unreadable(*a, **kw):
+ return False, False
+
+ monkeypatch.setattr(generate, "evaluate_feature_flag", flag_unreadable)
+ result = await generate.generate_and_deliver_briefing("user-1")
+ assert result == {"status": "skipped", "reason": "flag_unavailable"}
+
+
@pytest.mark.asyncio
async def test_generate_skips_when_already_delivered(monkeypatch):
from unittest.mock import AsyncMock, MagicMock
@@ -277,6 +291,9 @@ async def test_generate_skips_when_already_delivered(monkeypatch):
from backend.copilot.briefing import generate
monkeypatch.setattr(generate, "is_feature_enabled", AsyncMock(return_value=True))
+ monkeypatch.setattr(
+ generate, "evaluate_feature_flag", AsyncMock(return_value=(True, True))
+ )
user = MagicMock()
user.timezone = "UTC"
monkeypatch.setattr(
@@ -305,6 +322,9 @@ async def test_generate_delivers_and_composes_briefing(monkeypatch):
monkeypatch.setattr(generate, "datetime", fake_datetime)
monkeypatch.setattr(generate, "is_feature_enabled", AsyncMock(return_value=True))
+ monkeypatch.setattr(
+ generate, "evaluate_feature_flag", AsyncMock(return_value=(True, True))
+ )
user = MagicMock()
user.timezone = "UTC"
@@ -404,6 +424,9 @@ def _patch_generate_env(monkeypatch, generate, client):
fake_datetime.now.return_value = fixed_now
monkeypatch.setattr(generate, "datetime", fake_datetime)
monkeypatch.setattr(generate, "is_feature_enabled", AsyncMock(return_value=True))
+ monkeypatch.setattr(
+ generate, "evaluate_feature_flag", AsyncMock(return_value=(True, True))
+ )
user = MagicMock()
user.timezone = "UTC"
monkeypatch.setattr(
@@ -520,6 +543,9 @@ async def test_generate_keeps_library_link_when_workflow_has_no_library_agent_id
monkeypatch.setattr(generate, "datetime", fake_datetime)
monkeypatch.setattr(generate, "is_feature_enabled", AsyncMock(return_value=True))
+ monkeypatch.setattr(
+ generate, "evaluate_feature_flag", AsyncMock(return_value=(True, True))
+ )
user = MagicMock()
user.timezone = "UTC"
@@ -717,6 +743,9 @@ async def test_generate_writes_recomposed_content_back_to_an_unreadable_row(
fake_datetime.now.return_value = NOW
monkeypatch.setattr(generate, "datetime", fake_datetime)
monkeypatch.setattr(generate, "is_feature_enabled", AsyncMock(return_value=True))
+ monkeypatch.setattr(
+ generate, "evaluate_feature_flag", AsyncMock(return_value=(True, True))
+ )
user = MagicMock()
user.timezone = "UTC"
@@ -782,6 +811,9 @@ async def test_generate_stops_reprocessing_an_unreadable_row_with_nothing_to_say
fake_datetime.now.return_value = NOW
monkeypatch.setattr(generate, "datetime", fake_datetime)
monkeypatch.setattr(generate, "is_feature_enabled", AsyncMock(return_value=True))
+ monkeypatch.setattr(
+ generate, "evaluate_feature_flag", AsyncMock(return_value=(True, True))
+ )
user = MagicMock()
user.timezone = "UTC"
@@ -842,6 +874,9 @@ async def test_generate_bounds_the_execution_query(monkeypatch):
fake_datetime.now.return_value = NOW
monkeypatch.setattr(generate, "datetime", fake_datetime)
monkeypatch.setattr(generate, "is_feature_enabled", AsyncMock(return_value=True))
+ monkeypatch.setattr(
+ generate, "evaluate_feature_flag", AsyncMock(return_value=(True, True))
+ )
user = MagicMock()
user.timezone = "UTC"
@@ -1050,6 +1085,9 @@ async def test_ai_summary_flag_off_skips_generation_entirely(
"is_feature_enabled",
AsyncMock(side_effect=lambda flag, *a, **k: flag is Flag.HIRE_EXPERTS),
)
+ monkeypatch.setattr(
+ generate_module, "evaluate_feature_flag", AsyncMock(return_value=(True, True))
+ )
result = await generate_module.generate_and_deliver_briefing("user-1")
diff --git a/autogpt_platform/backend/backend/copilot/briefing/narrative.py b/autogpt_platform/backend/backend/copilot/briefing/narrative.py
index 97e4ae251c..37ababe47e 100644
--- a/autogpt_platform/backend/backend/copilot/briefing/narrative.py
+++ b/autogpt_platform/backend/backend/copilot/briefing/narrative.py
@@ -217,8 +217,11 @@ def _system_prompt(expert: Expert | None) -> str:
voice = fence_voice_preferences(
_clean(expert.voice_preferences, _MAX_PERSONA_CHARS)
)
+ # An expert with no role would otherwise render as
+ # "You are Geronimo — , a hired expert on the user's team."
+ headline = f"You are {name} — {role}," if role else f"You are {name},"
persona = (
- f"You are {name} — {role}, a hired expert on the user's team.\n"
+ f"{headline} a hired expert on the user's team.\n"
f"<identity>\n{identity}\n</identity>\n"
f"<voice_preferences>\n{voice}\n</voice_preferences>"
)
diff --git a/autogpt_platform/backend/backend/copilot/briefing/narrative_test.py b/autogpt_platform/backend/backend/copilot/briefing/narrative_test.py
index 5a44d9e3bb..f706024e41 100644
--- a/autogpt_platform/backend/backend/copilot/briefing/narrative_test.py
+++ b/autogpt_platform/backend/backend/copilot/briefing/narrative_test.py
@@ -176,6 +176,29 @@ async def test_expert_voice_carries_the_soul_document():
assert "You are Ana — Researcher" in system
+async def test_an_expert_with_a_role_keeps_the_dash_clause():
+ with patch_llm(return_value=completion("Morning.")) as mock:
+ await compose_narrative(USER, make_content(), [make_expert()])
+
+ system = mock.await_args.kwargs["messages"][0]["content"]
+ assert "You are Ana — Researcher, a hired expert on the user's team." in system
+
+
+async def test_an_expert_with_no_role_drops_the_dash_clause():
+ """An unset role rendered as "You are Ana — , a hired expert ..." — a
+ stray dash and comma in the persona line of a system prompt."""
+ expert = make_expert()
+ expert.role = ""
+ with patch_llm(return_value=completion("Morning.")) as mock:
+ await compose_narrative(USER, make_content(), [expert])
+
+ system = mock.await_args.kwargs["messages"][0]["content"]
+ assert "You are Ana, a hired expert on the user's team." in system
+ assert " — ," not in system
+
+
@pytest.mark.asyncio
async def test_voice_preferences_are_fenced_in_the_narrative_prompt():
"""A pasted writing sample carrying an injection reaches this prompt too
diff --git a/autogpt_platform/backend/backend/executor/scheduler.py b/autogpt_platform/backend/backend/executor/scheduler.py
index e3646bec16..dd4efb46b0 100644
--- a/autogpt_platform/backend/backend/executor/scheduler.py
+++ b/autogpt_platform/backend/backend/executor/scheduler.py
@@ -810,10 +810,34 @@ def execute_morning_briefing(user_id: str) -> None:
timeout=SCHEDULER_OPERATION_TIMEOUT_SECONDS,
)
logger.info("Morning briefing for user %s: %s", user_id[:12], result)
+ if result.get("reason") == "flag_disabled":
+ run_async(
+ _self_delete_morning_briefing_schedule(user_id),
+ timeout=SCHEDULER_OPERATION_TIMEOUT_SECONDS,
+ )
except Exception as e:
logger.error("Morning briefing failed for user %s: %s", user_id[:12], e)
+async def _self_delete_morning_briefing_schedule(user_id: str) -> None:
+ """Drop a briefing cron whose feature flag has since been turned off.
+
+ The registration marker goes with it: left set, it would suppress lazy
+ re-registration for the rest of its TTL if the flag comes back on.
+ Best-effort — the next daily fire retries the cleanup.
+ """
+ from backend.copilot.briefing.scheduling import clear_briefing_registration_marker
+
+ try:
+ await get_scheduler_client().remove_morning_briefing_schedule(user_id=user_id)
+ await clear_briefing_registration_marker(user_id)
+ except Exception:
+ logger.warning(
+ f"Failed to remove morning briefing job for user {user_id[:12]}",
+ exc_info=True,
+ )
+
+
def execute_nightly_batch_sync(user_id: str):
"""Per-user nightly batch-family fan-out cron body.
@@ -2495,6 +2519,24 @@ class Scheduler(AppService):
),
}
+ @expose
+ def remove_morning_briefing_schedule(self, user_id: str) -> dict:
+ """Delete one user's morning-briefing cron.
+
+ Deliberately not routed through ``delete_graph_execution_schedule``:
+ that path authorizes via ``_job_to_info``, which parses only graph and
+ copilot-turn kwargs and would reject this job's ``{"user_id": ...}``
+ shape as corrupt. The job id embeds the user id, so it is self-scoping.
+ """
+ job_id = f"morning_briefing_{user_id}"
+ job = self.scheduler.get_job(job_id, jobstore=Jobstores.EXECUTION.value)
+ if job is None:
+ return {"id": job_id, "user_id": user_id, "removed": False}
+ job.remove()
+ self._invalidate_jobs_cache()
+ logger.info(f"Removed morning briefing job {job_id} for user {user_id[:12]}")
+ return {"id": job_id, "user_id": user_id, "removed": True}
+
# --- Dream nightly batch (P-0.2 + P-0.4 consolidated) ---
#
# ONE per-user cron at user-local 03:00 fans out all batch-family
@@ -2718,6 +2760,9 @@ class SchedulerClient(AppServiceClient):
add_morning_briefing_schedule = endpoint_to_async(
Scheduler.add_morning_briefing_schedule
)
+ remove_morning_briefing_schedule = endpoint_to_async(
+ Scheduler.remove_morning_briefing_schedule
+ )
add_nightly_batch_schedule = endpoint_to_async(Scheduler.add_nightly_batch_schedule)
delete_nightly_batch_schedule = endpoint_to_async(
diff --git a/autogpt_platform/backend/backend/executor/scheduler_unit_test.py b/autogpt_platform/backend/backend/executor/scheduler_unit_test.py
index 8170f2bab2..135b90ca1a 100644
--- a/autogpt_platform/backend/backend/executor/scheduler_unit_test.py
+++ b/autogpt_platform/backend/backend/executor/scheduler_unit_test.py
@@ -33,6 +33,7 @@ from backend.executor.scheduler import (
_reschedule_one_shot_after_cap,
_reschedule_one_shot_after_expert_unavailable,
_self_delete_copilot_turn_schedule,
+ _self_delete_morning_briefing_schedule,
reconcile_stripe_tiers,
)
from backend.util.exceptions import (
@@ -1747,3 +1748,122 @@ class TestMorningBriefingSchedule:
r.levelno == logging.ERROR and "Morning briefing failed" in r.getMessage()
for r in caplog.records
)
+
+ def _remove(self, existing=None, user_id="user-1"):
+ sched = Scheduler.__new__(Scheduler)
+ sched.scheduler = MagicMock()
+ sched.scheduler.get_job.return_value = existing
+ sched._invalidate_jobs_cache = MagicMock()
+ result = Scheduler.remove_morning_briefing_schedule(sched, user_id=user_id)
+ return sched, result
+
+ def test_removing_deletes_the_job_and_invalidates_the_read_cache(self):
+ job = MagicMock(id="morning_briefing_user-1")
+
+ sched, result = self._remove(existing=job)
+
+ job.remove.assert_called_once()
+ sched._invalidate_jobs_cache.assert_called_once()
+ assert result == {
+ "id": "morning_briefing_user-1",
+ "user_id": "user-1",
+ "removed": True,
+ }
+
+ def test_removing_a_job_that_is_already_gone_is_a_no_op(self):
+ """The job body retries on every fire, so a second pass must not
+ raise once the first one removed the schedule."""
+ sched, result = self._remove(existing=None)
+
+ sched._invalidate_jobs_cache.assert_not_called()
+ assert result["removed"] is False
+
+ def test_job_body_removes_the_schedule_once_the_flag_is_off(self):
+ """Without this the cron outlives the feature, firing daily forever
+ to return flag_disabled."""
+ from backend.executor.scheduler import execute_morning_briefing
+
+ with (
+ patch(
+ "backend.copilot.briefing.generate.generate_and_deliver_briefing",
+ new=MagicMock(),
+ ),
+ patch(
+ f"{_SCHEDULER_PATH}.run_async",
+ side_effect=[{"status": "skipped", "reason": "flag_disabled"}, None],
+ ),
+ patch(
+ f"{_SCHEDULER_PATH}._self_delete_morning_briefing_schedule",
+ new=MagicMock(),
+ ) as self_delete,
+ ):
+ execute_morning_briefing("user-1")
+
+ self_delete.assert_called_once_with("user-1")
+
+ @pytest.mark.parametrize(
+ "result",
+ [
+ {"status": "skipped", "reason": "nothing_to_say"},
+ {"status": "skipped", "reason": "already_delivered"},
+ # An unreachable LaunchDarkly must cost one morning, not the cron.
+ {"status": "skipped", "reason": "flag_unavailable"},
+ {"status": "delivered", "briefing_id": "b-1", "session_id": "s-1"},
+ ],
+ )
+ def test_job_body_keeps_the_schedule_on_every_other_outcome(self, result):
+ from backend.executor.scheduler import execute_morning_briefing
+
+ with (
+ patch(
+ "backend.copilot.briefing.generate.generate_and_deliver_briefing",
+ new=MagicMock(),
+ ),
+ patch(f"{_SCHEDULER_PATH}.run_async", side_effect=[result]),
+ patch(
+ f"{_SCHEDULER_PATH}._self_delete_morning_briefing_schedule",
+ new=MagicMock(),
+ ) as self_delete,
+ ):
+ execute_morning_briefing("user-1")
+
+ self_delete.assert_not_called()
+
+ @pytest.mark.asyncio
+ async def test_self_delete_also_clears_the_registration_marker(self):
+ """A marker left behind would suppress lazy re-registration for the
+ rest of its TTL if the flag is turned back on."""
+ client = MagicMock()
+ client.remove_morning_briefing_schedule = AsyncMock()
+ with (
+ patch(f"{_SCHEDULER_PATH}.get_scheduler_client", return_value=client),
+ patch(
+ "backend.copilot.briefing.scheduling."
+ "clear_briefing_registration_marker",
+ new=AsyncMock(),
+ ) as clear_marker,
+ ):
+ await _self_delete_morning_briefing_schedule("user-1")
+
+ client.remove_morning_briefing_schedule.assert_awaited_once_with(
+ user_id="user-1"
+ )
+ clear_marker.assert_awaited_once_with("user-1")
+
+ @pytest.mark.asyncio
+ async def test_self_delete_swallows_a_scheduler_rpc_failure(self, caplog):
+ """It runs inside a job body; raising here would fail the whole run."""
+ client = MagicMock()
+ client.remove_morning_briefing_schedule = AsyncMock(
+ side_effect=RuntimeError("pyro down")
+ )
+ with (
+ patch(f"{_SCHEDULER_PATH}.get_scheduler_client", return_value=client),
+ caplog.at_level(logging.WARNING),
+ ):
+ await _self_delete_morning_briefing_schedule("user-1")
+
+ assert any(
+ "Failed to remove morning briefing job" in r.getMessage()
+ for r in caplog.records
+ )
diff --git a/autogpt_platform/backend/backend/util/feature_flag.py b/autogpt_platform/backend/backend/util/feature_flag.py
index f9a74e6a3c..919f795432 100644
--- a/autogpt_platform/backend/backend/util/feature_flag.py
+++ b/autogpt_platform/backend/backend/util/feature_flag.py
@@ -268,14 +268,28 @@ async def _fetch_user_context_data(user_id: str) -> Context:
Returns:
LaunchDarkly Context object
"""
+ context, _ = await _fetch_user_context_status(user_id)
+ return context
+
+
+async def _fetch_user_context_status(user_id: str) -> tuple[Context, bool]:
+ """``(context, resolved)`` — see :func:`_fetch_user_context_data`.
+
+ ``resolved`` is False only when the lookup FAILED and the anonymous
+ context is standing in for real user data. A non-UUID key such as
+ ``"system"`` is anonymous by design and counts as resolved. The
+ distinction matters because an evaluation against a degraded context
+ still succeeds — it just answers for the wrong user — so callers acting
+ irreversibly on a ``False`` must not trust one.
+ """
try:
uuid.UUID(user_id)
except ValueError:
# Non-UUID key (e.g. "system") — skip user lookup, return anonymous context.
- return _anonymous_context(user_id)
+ return _anonymous_context(user_id), True
try:
- return await _fetch_user_context(user_id)
+ return await _fetch_user_context(user_id), True
except Exception as e:
logger.warning(
f"Failed to fetch user context for {user_id}: {e} — "
@@ -283,7 +297,7 @@ async def _fetch_user_context_data(user_id: str) -> Context:
"evaluations for this user may be degraded until the lookup "
"succeeds"
)
- return _anonymous_context(user_id)
+ return _anonymous_context(user_id), False
def _anonymous_context(user_id: str) -> Context:
@@ -352,6 +366,21 @@ async def get_feature_flag_value(
Returns:
The flag value from LaunchDarkly
"""
+ value, _ = await _evaluate_flag_value(flag_key, user_id, default)
+ return value
+
+
+async def _evaluate_flag_value(
+ flag_key: str, user_id: str, default: Any = None
+) -> tuple[Any, bool]:
+ """``(value, evaluated)`` for one raw flag read.
+
+ ``evaluated`` is False whenever *default* is standing in for an answer
+ LaunchDarkly could not give — no client, an uninitialised one, a failed
+ user-context lookup, or an evaluation that raised. An initialised client
+ is not on its own enough: the context lookup is a database read, so a
+ live client can still fail to produce a value.
+ """
try:
client = get_client()
@@ -360,10 +389,10 @@ async def get_feature_flag_value(
logger.debug(
f"LaunchDarkly not initialized, using default={default} for {flag_key}"
)
- return default
+ return default, False
# Get user context (role/email) from the Better Auth user table
- context = await _fetch_user_context_data(user_id)
+ context, context_resolved = await _fetch_user_context_status(user_id)
# Evaluate flag
result = client.variation(flag_key, context, default)
@@ -371,13 +400,15 @@ async def get_feature_flag_value(
logger.debug(
f"Feature flag {flag_key} for user {user_id}: {result} (type: {type(result).__name__})"
)
- return result
+ # A degraded context evaluates fine, it just answers for an anonymous
+ # user rather than this one — so the value is a guess, not an answer.
+ return result, context_resolved
except Exception as e:
logger.warning(
f"LaunchDarkly flag evaluation failed for {flag_key}: {e}, using default={default}"
)
- return default
+ return default, False
def _env_flag_override(flag_key: Flag) -> bool | None:
@@ -420,16 +451,33 @@ async def is_feature_enabled(
Returns:
True if feature is enabled, False otherwise
"""
+ enabled, _ = await evaluate_feature_flag(flag_key, user_id, default)
+ return enabled
+
+
+async def evaluate_feature_flag(
+ flag_key: Flag,
+ user_id: str,
+ default: bool = False,
+) -> tuple[bool, bool]:
+ """``(enabled, authoritative)`` for one flag read.
+
+ ``authoritative`` is False when *enabled* is only the default, because the
+ flag could not be evaluated or came back as a non-boolean. Use this rather
+ than :func:`is_feature_enabled` wherever "off" triggers something
+ irreversible — a failed read is indistinguishable from a real "off" on the
+ value alone.
+ """
override = _env_flag_override(flag_key)
if override is not None:
logger.debug(f"Feature flag {flag_key} overridden by env: {override}")
- return override
+ return override, True
- result = await get_feature_flag_value(flag_key.value, user_id, default)
+ result, evaluated = await _evaluate_flag_value(flag_key.value, user_id, default)
# If the result is already a boolean, return it
if isinstance(result, bool):
- return result
+ return result, evaluated
# Log a warning if the flag is not returning a boolean
logger.warning(
@@ -437,9 +485,9 @@ async def is_feature_enabled(
f"This flag should be configured as a boolean in LaunchDarkly. Using default={default}"
)
- # Return the default if we get a non-boolean value
- # This prevents objects from being incorrectly treated as True
- return default
+ # A misconfigured flag is not an answer either: fall back to the default,
+ # but never let a caller take an irreversible action on it.
+ return default, False
def feature_flag(
diff --git a/autogpt_platform/backend/backend/util/feature_flag_test.py b/autogpt_platform/backend/backend/util/feature_flag_test.py
index 334e487779..d39ff01cc4 100644
--- a/autogpt_platform/backend/backend/util/feature_flag_test.py
+++ b/autogpt_platform/backend/backend/util/feature_flag_test.py
@@ -4,13 +4,14 @@ import uuid
import pytest
from fastapi import HTTPException
-from ldclient import LDClient
+from ldclient import Context, LDClient
import backend.util.feature_flag as feature_flag_module
from backend.util.feature_flag import (
Flag,
_env_flag_override,
_fetch_user_context_data,
+ evaluate_feature_flag,
feature_flag,
get_client,
is_feature_enabled,
@@ -110,16 +111,15 @@ def test_flag_enum_values():
@pytest.mark.asyncio
async def test_is_feature_enabled_with_flag_enum(mocker):
"""Test is_feature_enabled function with Flag enum."""
- mock_get_feature_flag_value = mocker.patch(
- "backend.util.feature_flag.get_feature_flag_value"
- )
- mock_get_feature_flag_value.return_value = True
+ mock_evaluate = mocker.patch("backend.util.feature_flag._evaluate_flag_value")
+ mock_evaluate.return_value = (True, True)
result = await is_feature_enabled(Flag.AUTOMOD, "user123")
assert result is True
# Should call with the flag's string value
- mock_get_feature_flag_value.assert_called_once()
+ mock_evaluate.assert_called_once()
+ assert mock_evaluate.call_args.args[0] == Flag.AUTOMOD.value
class TestEnvFlagOverride:
@@ -499,3 +499,85 @@ class TestShutdown:
get_client()
assert warn.call_count == 1
+
+
+class TestEvaluateFeatureFlag:
+ """Callers that delete state on a False need to know it was a real answer."""
+
+ @pytest.fixture(autouse=True)
+ def no_env_override(self, monkeypatch: pytest.MonkeyPatch):
+ """`.env` may force unrelated flags; pin this one to LaunchDarkly."""
+ monkeypatch.delenv("FORCE_FLAG_HIRE_EXPERTS", raising=False)
+ monkeypatch.delenv("NEXT_PUBLIC_FORCE_FLAG_HIRE_EXPERTS", raising=False)
+
+ @pytest.fixture
+ def user_context(self, mocker):
+ """A resolved context, so `authoritative` turns purely on evaluation."""
+ return mocker.patch(
+ "backend.util.feature_flag._fetch_user_context_status",
+ return_value=(Context.create("u-1"), True),
+ )
+
+ @pytest.mark.asyncio
+ async def test_a_successful_evaluation_is_authoritative(
+ self, ld_client, user_context
+ ):
+ ld_client.variation.return_value = False
+ assert await evaluate_feature_flag(Flag.HIRE_EXPERTS, "u-1") == (False, True)
+
+ @pytest.mark.asyncio
+ async def test_an_uninitialised_client_is_not(self, ld_client, user_context):
+ ld_client.is_initialized.return_value = False
+ assert await evaluate_feature_flag(Flag.HIRE_EXPERTS, "u-1") == (False, False)
+
+ @pytest.mark.asyncio
+ async def test_an_evaluation_that_raises_is_not(self, ld_client, user_context):
+ """The regression this class exists for: a LIVE client can still fail
+ to produce a value, and that must not read as a real "off"."""
+ ld_client.variation.side_effect = Exception("evaluation exploded")
+ assert await evaluate_feature_flag(Flag.HIRE_EXPERTS, "u-1") == (False, False)
+
+ @pytest.mark.asyncio
+ async def test_a_degraded_user_context_is_not(self, ld_client, mocker):
+ """The context lookup is a database read that SWALLOWS its failure and
+ returns an anonymous context, so evaluation still succeeds — against
+ the wrong user. That value must not be trusted as an answer."""
+ mock_prisma = mocker.patch("backend.data.db.prisma")
+ mock_prisma.is_connected.return_value = True
+ mocker.patch(
+ "backend.data.user.get_auth_user_flag_fields",
+ new=mocker.AsyncMock(side_effect=ConnectionError("database unreachable")),
+ )
+ ld_client.variation.return_value = False
+
+ result = await evaluate_feature_flag(Flag.HIRE_EXPERTS, str(uuid.uuid4()))
+
+ assert result == (False, False)
+ ld_client.variation.assert_called_once()
+
+ @pytest.mark.asyncio
+ async def test_a_non_boolean_flag_value_is_not(self, ld_client, user_context):
+ ld_client.variation.return_value = {"some": "object"}
+ assert await evaluate_feature_flag(Flag.HIRE_EXPERTS, "u-1") == (False, False)
+
+ @pytest.mark.asyncio
+ async def test_an_env_override_answers_without_launchdarkly(
+ self, mocker, monkeypatch: pytest.MonkeyPatch
+ ):
+ """A forced flag is a real answer, so acting on its False is safe."""
+ mocker.patch(
+ "backend.util.feature_flag.get_client",
+ side_effect=Exception("set_config was not called"),
+ )
+ monkeypatch.setenv("FORCE_FLAG_HIRE_EXPERTS", "false")
+ assert await evaluate_feature_flag(Flag.HIRE_EXPERTS, "u-1") == (False, True)
+
+ @pytest.mark.asyncio
+ async def test_is_feature_enabled_still_returns_the_bare_value(
+ self, ld_client, user_context
+ ):
+ """The refactor must not change what existing callers see."""
+ ld_client.variation.return_value = True
+ assert await is_feature_enabled(Flag.HIRE_EXPERTS, "u-1") is True
+ ld_client.variation.side_effect = Exception("boom")
+ assert await is_feature_enabled(Flag.HIRE_EXPERTS, "u-1") is False