test(#1423): add diamond OR + cross-schema trace tests; fix Rule 3 docstring

Addresses the before-merge coverage @ttngu207 and @MilagrosMarin flagged on
#1471 (the two they singled out as worth adding before merge):

- test_trace_multi_hop_diamond_or_convergence: an ancestor reached via two
  MULTI-HOP arms (Leaf -> {Left, Right} -> Root), asserting the OR-union
  {1, 2}. Guards the multi-pass accumulation in the reverse-topo walk, where a
  regression would silently drop an arm and yield a subset.
- test_trace_cross_schema_ancestor: seed and ancestor in different schemas,
  exercising load_all_upstream's unloaded-ancestor-schema discovery. Runs on
  both MySQL and PostgreSQL via schema_by_backend.

Also fixes the Backward Rule 3 docstring drift (diagram.py): it described
child.proj() but the code projects child.proj(*attr_map.keys()) to carry the
FK columns.

Upward Part-of-Part chains and an isolated non-aliased secondary-FK test remain
as noted follow-ups.

Author: dimitri-yatsenko

src/datajoint/diagram.py

@@ -863,7 +863,9 @@ def _apply_propagation_rule_upward(self, child_ft, child_attrs, parent_node, att
            ``child.proj(**{parent: child for child, parent in attr_map.items()})``
            — reverses the renaming so the result has parent's column names.
         3. Non-aliased AND child restriction attrs ⊄ parent PK:
-           ``child.proj()`` — project child to parent's PK columns.
+           ``child.proj(*attr_map.keys())`` — project child onto its FK columns
+           (which, being non-aliased, share names with parent's PK columns) so
+           the subsequent restriction on the parent joins on the right columns.
         """
         parent_pk = self.nodes[parent_node].get("primary_key", set())
 

tests/integration/test_trace.py

@@ -274,6 +274,104 @@ class Child(dj.Manual):
     assert counts[Child.full_table_name] == 2
 
 
+def test_trace_multi_hop_diamond_or_convergence(schema_by_backend):
+    """Diamond: an ancestor reached via two MULTI-HOP paths → OR-union across
+    both arms. Unlike test_trace_or_convergence_two_paths (adjacent two-edge
+    case), this forces the reverse-topo walk to accumulate a contributor for the
+    same ancestor across separate multi-pass arms. A regression that dropped an
+    OR arm would yield a subset here."""
+
+    @schema_by_backend
+    class Root(dj.Manual):
+        definition = """
+        root_id : int32
+        """
+
+    @schema_by_backend
+    class Left(dj.Manual):
+        definition = """
+        -> Root
+        left_id : int32
+        """
+
+    @schema_by_backend
+    class Right(dj.Manual):
+        # renamed FK avoids the root_id name collision when Leaf reconverges
+        definition = """
+        -> Root.proj(root_id2='root_id')
+        right_id : int32
+        """
+
+    @schema_by_backend
+    class Leaf(dj.Manual):
+        definition = """
+        -> Left
+        -> Right
+        leaf_id : int32
+        """
+
+    Root.insert([(1,), (2,), (3,)])
+    Left.insert([(1, 10)])  # Left row → Root 1
+    Right.insert([(2, 20)])  # Right row (root_id2=2) → Root 2
+    # Leaf PK order: root_id, left_id, root_id2, right_id, leaf_id
+    Leaf.insert([(1, 10, 2, 20, 100)])
+
+    trace = dj.Diagram.trace(Leaf & {"leaf_id": 100})
+
+    # Root reached via Leaf→Left→Root (root_id=1) OR Leaf→Right→Root
+    # (root_id2=2 reversed to root_id=2). Union = {1, 2}; Root 3 excluded.
+    contributing = set(trace[Root].fetch("root_id"))
+    assert contributing == {1, 2}
+
+
+def test_trace_cross_schema_ancestor(schema_by_backend, connection_by_backend):
+    """Ancestor in a DIFFERENT schema than the seed → load_all_upstream must
+    discover the unloaded ancestor schema via reverse FK-schema lookup."""
+    import time
+
+    backend = connection_by_backend.adapter
+    other_name = f"djtest_trace_other_{str(int(time.time() * 1000))[-8:]}"[:64]
+    if connection_by_backend.is_connected:
+        try:
+            connection_by_backend.query(f"DROP DATABASE IF EXISTS {backend.quote_identifier(other_name)}")
+        except Exception:
+            pass
+    other = dj.Schema(other_name, connection=connection_by_backend)
+
+    try:
+
+        @schema_by_backend
+        class Upstream(dj.Manual):
+            definition = """
+            up_id : int32
+            ---
+            label : varchar(32)
+            """
+
+        @other
+        class Downstream(dj.Manual):
+            # cross-schema FK: Downstream lives in `other`, Upstream in schema_by_backend
+            definition = """
+            -> Upstream
+            down_id : int32
+            """
+
+        Upstream.insert([(1, "a"), (2, "b")])
+        Downstream.insert([(1, 10), (2, 20)])
+
+        trace = dj.Diagram.trace(Downstream & {"up_id": 1, "down_id": 10})
+
+        assert len(trace[Upstream]) == 1
+        assert trace[Upstream].fetch1("up_id") == 1
+        assert trace[Upstream].fetch1("label") == "a"
+    finally:
+        if connection_by_backend.is_connected:
+            try:
+                connection_by_backend.query(f"DROP DATABASE IF EXISTS {backend.quote_identifier(other_name)}")
+            except Exception:
+                pass
+
+
 def test_trace_seed_with_no_ancestors(schema_by_backend):
     """Tracing from a table with no FK parents → trace contains only the seed."""