@@ -73,6 +73,12 @@ https://developers.google.com/style/inclusive-documentation
 
 -->
 
+### Dummy trigger rule has been deprecated
+
+`TriggerRule.DUMMY` is replaced by `TriggerRule.ALWAYS`.
+This is only name change, no functionality changes made.
+This change is backward compatible however `TriggerRule.DUMMY` will be removed in next major release.
+
 ### DAG concurrency settings have been renamed
 
 `[core] dag_concurrency` setting in `airflow.cfg` has been renamed to `[core] max_active_tasks_per_dag`
 
@@ -348,7 +348,7 @@ class derived from this one results in the creation of a task object,
     :param trigger_rule: defines the rule by which dependencies are applied
         for the task to get triggered. Options are:
         ``{ all_success | all_failed | all_done | one_success |
-        one_failed | none_failed | none_failed_or_skipped | none_skipped | dummy}``
+        one_failed | none_failed | none_failed_or_skipped | none_skipped | always}``
         default is ``all_success``. Options can be set as string or
         using the constants defined in the static class
         ``airflow.utils.TriggerRule``
@@ -542,6 +542,14 @@ def __init__(
         if end_date:
             self.end_date = timezone.convert_to_utc(end_date)
 
+        if trigger_rule == "dummy":
+            warnings.warn(
+                "dummy Trigger Rule is deprecated. Please use `TriggerRule.ALWAYS`.",
+                DeprecationWarning,
+                stacklevel=2,
+            )
+            trigger_rule = TriggerRule.ALWAYS
+
         if not TriggerRule.is_valid(trigger_rule):
             raise AirflowException(
                 "The trigger_rule must be one of {all_triggers},"
 
@@ -61,8 +61,8 @@ def _get_dep_statuses(self, ti, session, dep_context):
             yield self._passing_status(reason="The task instance did not have any upstream tasks.")
             return
 
-        if ti.task.trigger_rule == TR.DUMMY:
-            yield self._passing_status(reason="The task had a dummy trigger rule set.")
+        if ti.task.trigger_rule == TR.ALWAYS:
+            yield self._passing_status(reason="The task had a always trigger rule set.")
             return
         # see if the task name is in the task upstream for our task
         successes, skipped, failed, upstream_failed, done = self._get_states_count_upstream_ti(
 
@@ -31,6 +31,7 @@ class TriggerRule:
     NONE_FAILED_OR_SKIPPED = 'none_failed_or_skipped'
     NONE_SKIPPED = 'none_skipped'
     DUMMY = 'dummy'
+    ALWAYS = 'always'
 
     _ALL_TRIGGER_RULES: Set[str] = set()
 
 
@@ -337,7 +337,7 @@ However, this is just the default behaviour, and you can control it using the ``
 * ``none_failed``: All upstream tasks have not ``failed`` or ``upstream_failed`` - that is, all upstream tasks have succeeded or been skipped
 * ``none_failed_or_skipped``: All upstream tasks have not ``failed`` or ``upstream_failed``, and at least one upstream task has succeeded.
 * ``none_skipped``: No upstream task is in a ``skipped`` state - that is, all upstream tasks are in a ``success``, ``failed``, or ``upstream_failed`` state
-* ``dummy``: No dependencies at all, run this task at any time
+* ``always``: No dependencies at all, run this task at any time
 
 You can also combine this with the :ref:`concepts:depends-on-past` functionality if you wish.
 
 
@@ -31,6 +31,7 @@
 from airflow.models.baseoperator import BaseOperatorMeta, chain, cross_downstream
 from airflow.operators.dummy import DummyOperator
 from airflow.utils.edgemodifier import Label
+from airflow.utils.trigger_rule import TriggerRule
 from tests.models import DEFAULT_DATE
 from tests.test_utils.mock_operators import DeprecatedOperator, MockNamedTuple, MockOperator
 
@@ -595,6 +596,25 @@ def test_set_xcomargs_dependencies_error_when_outside_dag(self):
             op1 = DummyOperator(task_id="op1")
             CustomOp(task_id="op2", field=op1.output)
 
+    def test_invalid_trigger_rule(self):
+        with pytest.raises(
+            AirflowException,
+            match=(
+                f"The trigger_rule must be one of {TriggerRule.all_triggers()},"
+                "'.op1'; received 'some_rule'."
+            ),
+        ):
+            DummyOperator(task_id="op1", trigger_rule="some_rule")
+
+    @parameterized.expand((("string", "dummy"), ("enum", TriggerRule.DUMMY)))
+    def test_replace_dummy_trigger_rule(self, name, rule):
+        with pytest.warns(
+            DeprecationWarning, match="dummy Trigger Rule is deprecated. Please use `TriggerRule.ALWAYS`."
+        ):
+            op1 = DummyOperator(task_id="op1", trigger_rule=rule)
+
+            assert op1.trigger_rule == TriggerRule.ALWAYS
+
 
 class InitSubclassOp(DummyOperator):
     def __init_subclass__(cls, class_arg=None, **kwargs) -> None:
 
@@ -48,11 +48,11 @@ def test_no_upstream_tasks(self):
         ti = self._get_task_instance(TriggerRule.ALL_DONE, State.UP_FOR_RETRY)
         assert TriggerRuleDep().is_met(ti=ti)
 
-    def test_dummy_tr(self):
+    def test_always_tr(self):
         """
-        The dummy trigger rule should always pass this dep
+        The always trigger rule should always pass this dep
         """
-        ti = self._get_task_instance(TriggerRule.DUMMY, State.UP_FOR_RETRY)
+        ti = self._get_task_instance(TriggerRule.ALWAYS, State.UP_FOR_RETRY)
         assert TriggerRuleDep().is_met(ti=ti)
 
     def test_one_success_tr_success(self):
 
@@ -32,4 +32,5 @@ def test_valid_trigger_rules(self):
         assert TriggerRule.is_valid(TriggerRule.NONE_FAILED_OR_SKIPPED)
         assert TriggerRule.is_valid(TriggerRule.NONE_SKIPPED)
         assert TriggerRule.is_valid(TriggerRule.DUMMY)
-        assert len(TriggerRule.all_triggers()) == 9
+        assert TriggerRule.is_valid(TriggerRule.ALWAYS)
+        assert len(TriggerRule.all_triggers()) == 10