fix(sources): avoid calling closed SpiralDBConnector in to_config

SpiralDBTableSource.to_config() was delegating to super().to_config()
(DBTableSource), which called self._connector.to_config(). Because
SpiralDBConnector.to_config() raises RuntimeError once closed, and the
connector is always closed in __init__ after the eager data load, every
call to to_config() on a real SpiralDBTableSource instance would raise.

Fix: override to_config() to build the dict directly from the already-
captured instance attributes, bypassing the closed connector entirely.

Also update _make_mock_connector() in the test suite so close() flips a
flag and to_config() raises RuntimeError when closed, matching real
SpiralDBConnector behaviour. Add test_to_config_works_after_connector_is_closed
as an explicit regression guard.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: 2 people

src/orcapod/core/sources/spiraldb_table_source.py

@@ -138,15 +138,26 @@ def __init__(
                 pass
 
     def to_config(self) -> dict[str, Any]:
-        """Serialize source configuration to a JSON-compatible dict."""
-        base = super().to_config()
-        base.pop("connector", None)
+        """Serialize source configuration to a JSON-compatible dict.
+
+        Note:
+            Does **not** call ``super().to_config()`` (i.e. ``DBTableSource.to_config()``)
+            because that would invoke ``self._connector.to_config()``, which raises
+            ``RuntimeError`` once the connector has been closed. The connector is always
+            closed during ``__init__`` after the eager data load, so the full dict is
+            built from the already-captured instance attributes instead.
+        """
         return {
-            **base,
             "source_type": "spiraldb_table",
             "project_id": self._project_id,
             "dataset": self._dataset,
             "overrides": self._overrides,
+            "table_name": self._table_name,
+            "tag_columns": list(self._tag_columns),
+            "system_tag_columns": list(self._system_tag_columns),
+            "record_id_column": self._record_id_column,
+            "source_id": self.source_id,
+            **self._identity_config(),
         }
 
     @classmethod

tests/test_core/sources/test_spiraldb_table_source.py

@@ -38,7 +38,12 @@ def _make_mock_connector(
     pk_columns: list[str] | None = None,
     batches: list[pa.RecordBatch] | None = None,
 ) -> MagicMock:
-    """Return a MagicMock that satisfies DBConnectorProtocol for the given data.
+    """Return a MagicMock that faithfully simulates SpiralDBConnector lifecycle.
+
+    Specifically, ``close()`` flips a closed flag and ``to_config()`` raises
+    ``RuntimeError`` once closed — matching the real ``SpiralDBConnector``
+    behaviour.  This ensures tests catch bugs where ``to_config()`` (or any
+    other post-close call) is accidentally delegated to the connector.
 
     Args:
         table_names: Tables reported by ``get_table_names()``.
@@ -63,6 +68,27 @@ def _make_mock_connector(
     connector.get_table_names.return_value = table_names
     connector.get_pk_columns.return_value = pk_columns
     connector.iter_batches.return_value = iter(batches)
+
+    # Simulate the closed-connector lifecycle: close() flips the flag and
+    # to_config() raises RuntimeError afterwards, exactly as the real
+    # SpiralDBConnector does.
+    connector._closed = False
+
+    def _close():
+        connector._closed = True
+
+    def _to_config():
+        if connector._closed:
+            raise RuntimeError("SpiralDBConnector is closed")
+        return {
+            "connector_type": "spiraldb",
+            "project_id": _PROJECT_ID,
+            "dataset": _DATASET,
+            "overrides": None,
+        }
+
+    connector.close.side_effect = _close
+    connector.to_config.side_effect = _to_config
     return connector
 
 
@@ -607,6 +633,26 @@ def test_to_config_has_identity_fields(self):
         assert "content_hash" in cfg
         assert "pipeline_hash" in cfg
 
+    def test_to_config_works_after_connector_is_closed(self):
+        """to_config() must not call the connector — it is closed after __init__.
+
+        Regression test: the mock connector's to_config() raises RuntimeError
+        when closed (matching SpiralDBConnector's behaviour).  If
+        SpiralDBTableSource.to_config() delegates to the connector, this test
+        will raise RuntimeError and fail.
+        """
+        from orcapod.core.sources import SpiralDBTableSource
+
+        connector = _make_mock_connector()
+        with _patch_connector(connector):
+            src = SpiralDBTableSource(_PROJECT_ID, _TABLE_NAME)
+        # Connector is closed at this point; calling to_config() must not
+        # raise.
+        assert connector._closed, "connector should be closed after __init__"
+        cfg = src.to_config()  # must not raise RuntimeError
+        assert cfg["source_type"] == "spiraldb_table"
+        assert cfg["project_id"] == _PROJECT_ID
+
     def test_from_config_reconstructs_successfully(self):
         from orcapod.core.sources import SpiralDBTableSource