FIX/BREAK(fnop.test): Aliases TC insidiously broken >

and missed `as_renames()`misparsed DICT ALIASES with 2-CHAR KEYS.

- BREAK(op) stop accepting 2-element aliases (cwmust always be an iterable).
- test: enhanced the TC that got the bug in the first place
  and the short-circuited one.
- test(plan) lazily create parametrized operations, in case code breaks
  while developing it.
- x3 + x2 TCs fail.

Author: ankostis

docs/source/operations.rst

@@ -196,7 +196,7 @@ Sometimes, you need to interface functions & operations where they name a
        >>> op = operation(str,
        ...                name="cloning `provides` with an `alias`",
        ...                provides="real thing",
-       ...                aliases=("real thing", "clone"))
+       ...                aliases={"real thing": "clone"})
 
    .. graphtik::
 

graphtik/fnop.py

@@ -78,7 +78,7 @@ def identity_fn(*args, **kwargs):
 
 def as_renames(i, argname):
     """
-    Parses a list of (source-->destination) from dict, list-of-2-items, single 2-tuple.
+    Parses a list of (source-->destination) from dict or  list-of-2-items.
 
     :return:
         a (possibly empty)list-of-pairs
@@ -89,25 +89,15 @@ def as_renames(i, argname):
     if not i:
         return ()
 
-    def is_list_of_2(i):
-        try:
-            return all(len(ii) == 2 for ii in i)
-        except Exception:
-            pass  # Let it be, it may be a dictionary...
-
-    if isinstance(i, tuple) and len(i) == 2:
-        i = [i]
-    elif not isinstance(i, cabc.Collection):
-        raise TypeError(
-            f"Argument {argname} must be a list of 2-element items, was: {i!r}"
-        ) from None
-    elif not is_list_of_2(i):
-        try:
-            i = list(dict(i).items())
-        except Exception as ex:
-            raise ValueError(f"Cannot dict-ize {argname}({i!r}) due to: {ex}") from None
+    try:
+        i = i.items()
+    except Exception as ex:
+        if not isinstance(i, cabc.Collection) or not all(len(pair) == 2 for pair in i):
+            raise TypeError(
+                f"Argument {argname} must be a list of 2-element items, was: {i!r}"
+            ) from None
 
-    return i
+    return list(i)
 
 
 def prefixed(dep, cwd):
@@ -1042,7 +1032,9 @@ def operation(
 
 
     :param aliases:
-        an optional mapping of `provides` to additional ones
+        an optional mapping of `provides` to additional ones;  if you need to map
+        the same *source* provides into multiple *destinations*, use a list of tuples,
+        like: ``aliases=[("a", "A1"), ("a", "A2")]``.
     :param cwd:
         The :term:`current-working-document`, when given, all non-root `dependencies`
         (`needs`, `provides` & `aliases`) become :term:`jsonp`\\s, prefixed with this.

test/test_op.py

@@ -19,8 +19,8 @@
     keyword,
     operation,
     optional,
-    token,
     sfxed,
+    token,
     vararg,
     varargs,
     vcat,
@@ -347,16 +347,32 @@ def test_pipeline_merge_node_props():
 @pytest.mark.parametrize(
     "inp, exp",
     [
-        ({"a": "b"}, {"a": "b"}.items()),
-        ((1, 2), [(1, 2)]),
+        ([("", "")], [("", "")]),
+        ({"": ""}, [("", "")]),
+        ([("a", "b")], [("a", "b")]),
+        ((("a", "b"),), [("a", "b")]),
+        ([("ab", "b")], [("ab", "b")]),
+        ([("abc", "b")], [("abc", "b")]),
+        ({"a": "b"}, [("a", "b")]),
+        ({"ab": "b"}, [("ab", "b")]),
+        ({"abc": "b"}, [("abc", "b")]),
+        ([(token("a"), "b")], [(token("a"), "b")]),
+        ({token("a"): "b"}, [(token("a"), "b")]),
+        ({"abc": "b"}, [("abc", "b")]),
+        ({(1, 2)}, [(1, 2)]),
         ([(1, 2)], [(1, 2)]),
-        ([], []),
-        ((), []),
-        (("ab", "ad"), [("a", "b"), ("a", "d")]),
+        ([], ()),
+        ((), ()),
+        ([("a", "1"), ("a", "2")], [("a", "1"), ("a", "2")]),
+        ([("a", "3"), ("a", "2"), ("a", "1")], [("a", "3"), ("a", "2"), ("a", "1")]),
+        ([("a", "c"), ("e", "g")], [("a", "c"), ("e", "g")]),
+        ({"a": "c", "e": "g"}, [("a", "c"), ("e", "g")]),
+        ([("ab", "cd"), ("ef", "gh")], [("ab", "cd"), ("ef", "gh")]),
+        ({"ab": "cd", "ef": "gh"}, [("ab", "cd"), ("ef", "gh")]),
     ],
 )
 def test_as_renames(inp, exp):
-    as_renames((1, 2), "alias")
+    assert as_renames(inp, "alias") == exp
 
 
 @pytest.mark.parametrize(
@@ -386,14 +402,9 @@ def test_as_renames(inp, exp):
                 r"The `aliases` \['b'-->'B'\] rename non-existent provides in \['a'\]"
             ),
         ),
-        (
-            (token("a"), {token("a"): "a"}),
-            ValueError("must not contain `tokens`"),
-        ),
-        (
-            ("a", {"a": token("AA")}),
-            ValueError("must not contain `tokens`"),
-        ),
+        ((token("a"), {token("a"): "a"}), ValueError("must not contain `tokens`")),
+        (("a", {"a": token("AA")}), ValueError("must not contain `tokens`")),
+        (("a", {token("a"): "b"}), ValueError("rename non-existent provides")),
         (
             (["a", "b"], {"a": "b"}),
             ValueError(r"clash with existing provides in \['a', 'b'\]"),

test/test_planning.py

@@ -150,33 +150,33 @@ def test_yield_chained_docs_root(g):
     "ops, err",
     [
         (
-            [operation(str, "BOOM", provides="BOOM")],
+            lambda: [operation(str, "BOOM", provides="BOOM")],
             r"Name of provides\('BOOM'\) clashed with a same-named operation",
         ),
         (
-            [operation(str, "BOOM", needs="BOOM")],
+            lambda: [operation(str, "BOOM", needs="BOOM")],
             r"Name of operation\(BOOM\) clashed with a same-named dependency",
         ),
         (
-            [operation(str, "BOOM", provides="a", aliases=("a", "BOOM"))],
+            lambda: [operation(str, "BOOM", provides="a", aliases={"a": "BOOM"})],
             r"Name of provides\('BOOM'\) clashed with a same-named operation",
         ),
         (
-            [operation(str, "op1", provides="BOOM"), operation(str, "BOOM")],
+            lambda: [operation(str, "op1", provides="BOOM"), operation(str, "BOOM")],
             r"Name of operation\(BOOM\) clashed with a same-named dependency",
         ),
         ## x2 ops
         (
-            [operation(str, "BOOM"), operation(str, "op2", "BOOM")],
+            lambda: [operation(str, "BOOM"), operation(str, "op2", "BOOM")],
             r"Name of needs\('BOOM'\) clashed with a same-named operation",
         ),
         (
-            [operation(str, "op1", needs="BOOM"), operation(str, "BOOM")],
+            lambda: [operation(str, "op1", needs="BOOM"), operation(str, "BOOM")],
             r"Name of operation\(BOOM\) clashed with a same-named dependency",
         ),
         (
-            [
-                operation(str, "op1", provides="a", aliases=("a", "BOOM")),
+            lambda: [
+                operation(str, "op1", provides="a", aliases={"a": "BOOM"}),
                 operation(str, "BOOM"),
             ],
             r"Name of operation\(BOOM\) clashed with a same-named dependency",
@@ -185,4 +185,4 @@ def test_yield_chained_docs_root(g):
 )
 def test_node_clashes(ops, err):
     with pytest.raises(ValueError, match=err):
-        Network(*ops)
+        Network(*ops())