yaml: Dump tuple objects as !!python/tuple nodes

Before, `!!python/tuple` was only used for `OrderedDumper`.  Now it is
also used for `SafeOrderedDumper` and `IndentedSafeOrderedDumper`.

This is a behavior change: Any users that depended on a `tuple`
becoming a plain YAML sequence (which would be read in as a `list`
object) must first convert the `tuple` to `list`.

This change preserves the semantics of the object, and it preserves
round-trip identity.  Preserving round-trip identity is particularly
important if the tuple is used as a key in a `dict` because `list`
objects are not hashable.

Behavior before:

```pycon
>>> import salt.utils.yaml as y
>>> print(y.dump(("foo", "bar"), default_flow_style=False))
!!python/tuple
- foo
- bar

>>> print(y.safe_dump(("foo", "bar"), default_flow_style=False))
- foo
- bar

```

Behavior after:

```pycon
>>> import salt.utils.yaml as y
>>> print(y.dump(("foo", "bar"), default_flow_style=False))
!!python/tuple
- foo
- bar

>>> print(y.safe_dump(("foo", "bar"), default_flow_style=False))
!!python/tuple
- foo
- bar

```

changelog/62932.fixed

@@ -24,6 +24,9 @@ but can be previewed now by setting the option `yaml_compatibility` to `3007`:
     `datetime.datetime` object instead of a string.
   * Dumping a `datetime.datetime` object will explicitly tag the node with
     `!!timestamp`.  (Currently the nodes are untagged.)
+  * Dumping a `tuple` object will consistently produce a sequence node
+    explicitly tagged with `!!python/tuple`.  (Currently `safe_dump()` omits the
+    tag and `dump()` includes it.)
   * `salt.utils.yaml.dump()` will default to `salt.utils.yaml.OrderedDumper`
     instead of `yaml.Dumper`.
   * Dumping a YAML sequence with `salt.utils.yaml.IndentedSafeOrderedDumper`

doc/topics/troubleshooting/yaml_idiosyncrasies.rst

@@ -498,6 +498,13 @@ Tuples
 
     Loading a YAML ``!!python/tuple`` node is now supported.
 
+.. versionchanged:: 3007.0
+
+    Dumping a ``tuple`` object to YAML now always produces a sequence node
+    tagged with ``!!python/tuple``.  Previously, ``salt.utils.yaml.safe_dump()``
+    did not tag the node.  Set the ``yaml_compatibility`` option to 3006 to
+    revert to the previous behavior.
+
 The YAML ``!!python/tuple`` type can be used to produce a Python ``tuple``
 object when loaded:
 
@@ -507,10 +514,8 @@ object when loaded:
     - first item
     - second item
 
-When dumped to YAML with ``salt.utils.yaml.dump()``, a ``tuple`` object produces
-a ``!!python/tuple`` node.  When dumped to YAML with
-``salt.utils.yaml.safe_dump()``, a ``tuple`` object produces a plain sequence
-node (which will be loaded as a ``list`` object).
+When dumped to YAML, a ``tuple`` object produces a sequence node tagged with
+``!!python/tuple``.
 
 Beware that Salt currently serializes ``tuple`` objects the same way it
 serializes ``list`` objects, so they become ``list`` objects when deserialized

salt/utils/yamldumper.py

@@ -158,6 +158,10 @@ def _rep_default(self, data):
     salt.utils.context.NamespacedDictWrapper,
     yaml.representer.SafeRepresenter.represent_dict,
 )
+# SafeDumper represents tuples as lists, but Dumper's behavior (sequence
+# tagged with `!!python/tuple`) is safe, so use it for all dumpers.
+_CommonMixin.add_multi_representer(tuple, Dumper.yaml_representers[tuple])
+_CommonMixin.add_representer(tuple, Dumper.yaml_representers[tuple])
 
 
 class SafeOrderedDumper(_CommonMixin, SafeDumper):

tests/pytests/unit/utils/jinja/test_custom_extensions.py

@@ -130,6 +130,7 @@ def test_serialize_yaml():
         "baz": [1, 2, 3],
         "qux": 2.0,
         "spam": OrderedDict([("foo", OrderedDict([("bar", "baz"), ("qux", 42)]))]),
+        "tuple": ("foo", "bar"),
     }
     env = Environment(extensions=[SerializerExtension])
     rendered = env.from_string("{{ dataset|yaml }}").render(dataset=dataset)

tests/pytests/unit/utils/test_yaml.py

@@ -215,6 +215,28 @@ def test_dump_timestamp(yaml_compatibility, want_tag, dumpercls):
     assert re.fullmatch(want_re, got)
 
 
+@pytest.mark.parametrize(
+    "mktuple",
+    [
+        lambda *args: tuple(args),
+        collections.namedtuple("TestTuple", "a b"),
+    ],
+)
+@pytest.mark.parametrize(
+    "dumpercls",
+    [
+        salt_yaml.OrderedDumper,
+        salt_yaml.SafeOrderedDumper,
+        salt_yaml.IndentedSafeOrderedDumper,
+    ],
+)
+def test_dump_tuple(mktuple, dumpercls):
+    data = mktuple("foo", "bar")
+    want = "!!python/tuple [foo, bar]\n"
+    got = salt_yaml.dump(data, Dumper=dumpercls)
+    assert got == want
+
+
 def render_yaml(data):
     """
     Takes a YAML string, puts it into a mock file, passes that to the YAML