test(upsert): drop redundant TestUpsertScanProjection test

Removes ``test_when_matched_true_keeps_star_projection`` per review
feedback — the spy-on-init assertion that ``selected_fields=("*",)``
is preserved on the ``=True`` path is redundant with
``test_update_mode_actually_updates_non_key_columns``, which proves
the wide projection works end-to-end by detecting non-key value drift
through ``get_rows_to_update``. A regression that narrowed the
``=True`` projection unconditionally would fail the end-to-end test
because ``rows_updated`` would drop to 0 and the read-back would see
the stale value.

Leaves two focused tests in ``TestUpsertScanProjection``:

- ``test_when_matched_false_projects_join_cols_only`` pins the
  positive case (narrowing fires on the insert-on-no-match branch).
- ``test_update_mode_actually_updates_non_key_columns`` pins the
  negative case (the update branch keeps the wide projection it needs).

Co-authored-by: Cursor <[email protected]>

Author: Paul Mathew

tests/table/test_upsert.py

@@ -1012,41 +1012,15 @@ def test_when_matched_false_projects_join_cols_only(self, catalog: Catalog, capt
             f"expected every DataScan during upsert to use selected_fields=('order_id',); got {selected}"
         )
 
-    def test_when_matched_true_keeps_star_projection(self, catalog: Catalog, captured_scans: list[dict[str, Any]]) -> None:
-        """The update branch's ``get_rows_to_update`` compares non-key
-        columns to detect actual value changes — projecting only
-        ``join_cols`` would feed it data with no non-key columns to
-        compare and silently turn every match into a write-back. Must
-        keep ``("*",)``."""
-        table = self._build_partitioned_table(catalog, "default.test_upsert_projection_update_mode")
-        self._seed(table)
-        upsert_df = pa.Table.from_pylist(
-            [
-                {"order_id": 1, "order_date": datetime.date(2026, 1, 1), "order_type": "B"},
-                {"order_id": 3, "order_date": datetime.date(2026, 1, 3), "order_type": "B"},
-            ],
-            schema=self._arrow_schema(),
-        )
-
-        before = len(captured_scans)
-        res = table.upsert(df=upsert_df, join_cols=["order_id"], when_matched_update_all=True)
-        upsert_scans = captured_scans[before:]
-        assert res.rows_updated == 1
-        assert res.rows_inserted == 1
-
-        assert upsert_scans, "upsert path constructed no DataScan — projection contract regression"
-        selected = [s.get("selected_fields") for s in upsert_scans]
-        assert all(sf == ("*",) for sf in selected), (
-            f"expected every DataScan during upsert to keep selected_fields=('*',) for the update branch; got {selected}"
-        )
-
     def test_update_mode_actually_updates_non_key_columns(self, catalog: Catalog) -> None:
-        """End-to-end correctness pin: with ``when_matched_update_all=True``
-        the destination scan must read non-key columns so
-        ``get_rows_to_update`` can detect ``order_type`` changes. A
-        regression that narrows projection unconditionally would skip
-        the comparison and silently miss updates whose non-key columns
-        differ.
+        """End-to-end correctness pin for the ``when_matched_update_all=True``
+        branch: the destination scan must read non-key columns so
+        ``get_rows_to_update`` can detect ``order_type`` changes and
+        run the update. A regression that narrows projection
+        unconditionally would skip the comparison and silently miss
+        updates whose non-key columns differ — this test would fail
+        because ``rows_updated`` would drop to 0 and the read-back
+        would still see the old ``'A'``.
         """
         identifier = "default.test_upsert_update_mode_correctness"
         table = self._build_partitioned_table(catalog, identifier)