@@ -4130,8 +4130,28 @@ async def empty_callback_for_deadline():
41304130 pass
41314131
41324132
4133- def test_clear_task_instances_recalculates_dagrun_queued_deadlines (dag_maker , session ):
4134- """Test that clearing tasks recalculates all (and only) DAGRUN_QUEUED_AT deadlines."""
4133+ @pytest .mark .parametrize (
4134+ "use_variable_interval" ,
4135+ [
4136+ pytest .param (False , id = "fixed_timedelta_interval" ),
4137+ pytest .param (True , id = "variable_interval" ),
4138+ ],
4139+ )
4140+ def test_clear_task_instances_recalculates_dagrun_queued_deadlines (dag_maker , session , use_variable_interval ):
4141+ """Test that clearing tasks recalculates all (and only) DAGRUN_QUEUED_AT deadlines.
4142+
4143+ Since Airflow 3.3 the ``deadline_alert.interval`` column is JSON (a serialized ``timedelta``
4144+ or ``VariableInterval``), so the recalculation must decode it instead of passing the raw value
4145+ to ``timedelta()``. Storing the interval via ``serialize`` here mirrors production and covers
4146+ both interval kinds.
4147+ """
4148+ from airflow .sdk .definitions .deadline import VariableInterval
4149+ from airflow .sdk .definitions .variable import Variable
4150+ from airflow .sdk .serde import serialize
4151+
4152+ variable_key = "deadline_interval_key"
4153+ variable_seconds = 3600
4154+
41354155 with dag_maker (
41364156 dag_id = "test_recalculate_deadlines" ,
41374157 schedule = datetime .timedelta (days = 1 ),
@@ -4151,29 +4171,52 @@ def test_clear_task_instances_recalculates_dagrun_queued_deadlines(dag_maker, se
41514171 select (SerializedDagModel .id ).where (SerializedDagModel .dag_id == dag .dag_id )
41524172 )
41534173
4154- deadline_configs = [
4155- (DeadlineReference .DAGRUN_QUEUED_AT , datetime .timedelta (hours = 1 )),
4156- (DeadlineReference .DAGRUN_QUEUED_AT , datetime .timedelta (hours = 2 )),
4157- (DeadlineReference .FIXED_DATETIME , datetime .timedelta (hours = 1 )),
4174+ if use_variable_interval :
4175+ queued_interval = VariableInterval (variable_key )
4176+ queued_resolved = datetime .timedelta (seconds = variable_seconds )
4177+ # Both DAGRUN_QUEUED_AT deadlines resolve to the same interval from the Variable.
4178+ queued_configs = [
4179+ (DeadlineReference .DAGRUN_QUEUED_AT , queued_interval , queued_resolved ),
4180+ (DeadlineReference .DAGRUN_QUEUED_AT , queued_interval , queued_resolved ),
4181+ ]
4182+ else :
4183+ queued_configs = [
4184+ (
4185+ DeadlineReference .DAGRUN_QUEUED_AT ,
4186+ datetime .timedelta (hours = 1 ),
4187+ datetime .timedelta (hours = 1 ),
4188+ ),
4189+ (
4190+ DeadlineReference .DAGRUN_QUEUED_AT ,
4191+ datetime .timedelta (hours = 2 ),
4192+ datetime .timedelta (hours = 2 ),
4193+ ),
4194+ ]
4195+
4196+ # (reference type, interval stored on the alert, timedelta it resolves to)
4197+ deadline_configs = queued_configs + [
4198+ (DeadlineReference .FIXED_DATETIME , datetime .timedelta (hours = 1 ), datetime .timedelta (hours = 1 )),
41584199 ]
41594200
4160- for deadline_type , interval in deadline_configs :
4201+ expected_resolved_by_alert = {}
4202+ for deadline_type , stored_interval , resolved_interval in deadline_configs :
41614203 if deadline_type == DeadlineReference .DAGRUN_QUEUED_AT :
41624204 reference = DeadlineReference .DAGRUN_QUEUED_AT .serialize_reference ()
4163- deadline_time = dag_run .queued_at + interval
4205+ deadline_time = dag_run .queued_at + resolved_interval
41644206 else : # FIXED_DATETIME
41654207 future_date = timezone .utcnow () + datetime .timedelta (days = 7 )
41664208 reference = DeadlineReference .FIXED_DATETIME (future_date ).serialize_reference ()
4167- deadline_time = future_date + interval
4209+ deadline_time = future_date + resolved_interval
41684210
41694211 deadline_alert = DeadlineAlertModel (
41704212 serialized_dag_id = serialized_dag_id ,
41714213 reference = reference ,
4172- interval = interval . total_seconds ( ),
4214+ interval = serialize ( stored_interval ),
41734215 callback_def = {"path" : f"{ __name__ } .empty_callback_for_deadline" , "kwargs" : {}},
41744216 )
41754217 session .add (deadline_alert )
41764218 session .flush ()
4219+ expected_resolved_by_alert [deadline_alert .id ] = resolved_interval
41774220
41784221 deadline = Deadline (
41794222 dagrun_id = dag_run .id ,
@@ -4192,7 +4235,15 @@ def test_clear_task_instances_recalculates_dagrun_queued_deadlines(dag_maker, se
41924235 }
41934236
41944237 tis = session .scalars (select (TI ).where (TI .dag_id == dag .dag_id , TI .run_id == dag_run .run_id )).all ()
4195- clear_task_instances (tis , session )
4238+
4239+ # VariableInterval.resolve() reads the Airflow Variable during recalculation.
4240+ variable_ctx = (
4241+ mock .patch .object (Variable , "get" , return_value = str (variable_seconds ))
4242+ if use_variable_interval
4243+ else contextlib .nullcontext ()
4244+ )
4245+ with variable_ctx :
4246+ clear_task_instances (tis , session )
41964247
41974248 dag_run = session .scalar (select (DagRun ).where (DagRun .id == dag_run .id ))
41984249 assert dag_run .queued_at > original_queued_at
@@ -4205,8 +4256,7 @@ def test_clear_task_instances_recalculates_dagrun_queued_deadlines(dag_maker, se
42054256 for deadline in deadlines_after :
42064257 if deadline .deadline_time != deadline_times_by_alert [deadline .deadline_alert_id ]:
42074258 recalculated_count += 1
4208- deadline_alert = session .get (DeadlineAlertModel , deadline .deadline_alert_id )
4209- expected_time = dag_run .queued_at + datetime .timedelta (seconds = deadline_alert .interval )
4259+ expected_time = dag_run .queued_at + expected_resolved_by_alert [deadline .deadline_alert_id ]
42104260 assert deadline .deadline_time == expected_time
42114261
42124262 assert recalculated_count == 2
0 commit comments