test: Add comprehensive tests for TapTestRunner streams parameter

- Add tests for TapTestRunner initialization with streams parameter
- Add tests for run_sync_dry_run with streams parameter
- Add tests for different stream sequence types (list, tuple, empty)
- Add integration test for complete workflow with streams
- Fix factory tests to include streams=None parameter expectations

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <[email protected]>

Author: edgarrmondragon

singer_sdk/tap_base.py

@@ -261,7 +261,7 @@ def run_connection_test(self) -> bool:
     def run_sync_dry_run(
         self,
         dry_run_record_limit: int | None = 1,
-        streams: t.Iterable[Stream] | None = None,
+        streams: t.Iterable[Stream | str] | None = None,
     ) -> bool:
         """Run connection test.
 
@@ -278,15 +278,24 @@ def run_sync_dry_run(
         if streams is None:
             streams = self.streams.values()
 
-        for stream in streams:
+        selected_streams: list[Stream] = []
+
+        for stream_or_name in streams:
+            stream = (
+                self.streams[stream_or_name]
+                if isinstance(stream_or_name, str)
+                else stream_or_name
+            )
+
             if not stream.child_streams:  # pragma: no branch
                 # Initialize streams' record limits before beginning the sync test.
                 stream.ABORT_AT_RECORD_COUNT = dry_run_record_limit
 
             # Force selection of streams.
             stream.selected = True
+            selected_streams.append(stream)
 
-        for stream in streams:
+        for stream in selected_streams:
             if stream.parent_stream_type:
                 self.logger.debug(
                     "Child stream '%s' should be called by "

singer_sdk/testing/factory.py

@@ -17,6 +17,8 @@
 )
 
 if t.TYPE_CHECKING:
+    from collections.abc import Sequence
+
     from singer_sdk import Stream, Tap, Target
     from singer_sdk.testing.templates import (
         AttributeTestTemplate,
@@ -91,6 +93,7 @@ def new_test_class(
         include_stream_attribute_tests: bool = True,
         custom_suites: list | None = None,
         suite_config: SuiteConfig | None = None,
+        streams: Sequence[str] | None = None,
         **kwargs: t.Any,
     ) -> type[BaseTestClass]:
         """Get a new test class.
@@ -102,6 +105,7 @@ def new_test_class(
                 Include stream attribute tests in the test class.
             custom_suites: List of custom test suites to include in the test class.
             suite_config: SuiteConfig instance to be used when instantiating tests.
+            streams: Streams to test.
             kwargs: Default arguments to be passed to tap on create.
 
         Returns:
@@ -124,6 +128,7 @@ def new_test_class(
             tap_class=self.tap_class,
             config=self.config,
             suite_config=suite_config,
+            streams=streams,
             **kwargs,
         )
 
@@ -396,6 +401,7 @@ def get_tap_test_class(
     include_stream_attribute_tests: bool = True,
     custom_suites: list | None = None,
     suite_config: SuiteConfig | None = None,
+    streams: Sequence[str] | None = None,
     **kwargs: t.Any,
 ) -> type[BaseTestClass]:
     """Get Tap Test Class.
@@ -408,6 +414,7 @@ def get_tap_test_class(
         include_stream_attribute_tests: Include Tap stream attribute tests.
         custom_suites: Custom test suites to add to standard tests.
         suite_config: SuiteConfig instance to pass to tests.
+        streams: Streams to test.
         kwargs: Keyword arguments to pass to the TapRunner.
 
     Returns:
@@ -423,6 +430,7 @@ def get_tap_test_class(
         include_tap_tests=include_tap_tests,
         include_stream_tests=include_stream_tests,
         include_stream_attribute_tests=include_stream_attribute_tests,
+        streams=streams,
         **kwargs,
     )
 

singer_sdk/testing/runners.py

@@ -7,6 +7,7 @@
 import json
 import typing as t
 from collections import defaultdict
+from collections.abc import Sequence
 from contextlib import redirect_stderr, redirect_stdout
 
 from singer_sdk import Tap, Target
@@ -96,6 +97,8 @@ def __init__(
         tap_class: type[Tap],
         config: dict | None = None,
         suite_config: SuiteConfig | None = None,
+        *,
+        streams: Sequence[str] | None = None,
         **kwargs: t.Any,
     ) -> None:
         """Initialize Tap instance.
@@ -105,6 +108,7 @@ def __init__(
             config: Config dict to pass to Tap class.
             suite_config (SuiteConfig): SuiteConfig instance to be used when
                 instantiating tests.
+            streams: Streams to test.
             kwargs: Default arguments to be passed to tap on create.
         """
         super().__init__(
@@ -113,6 +117,7 @@ def __init__(
             suite_config=suite_config,
             **kwargs,
         )
+        self.streams = streams
 
     def new_tap(self) -> Tap:
         """Get new Tap instance.
@@ -148,6 +153,7 @@ def run_sync_dry_run(self) -> bool:
         new_tap = self.new_tap()
         return new_tap.run_sync_dry_run(
             dry_run_record_limit=self.suite_config.max_records_limit,
+            streams=self.streams,
         )
 
     def sync_all(self, **kwargs: t.Any) -> None:  # noqa: ARG002

tests/core/testing/test_factory.py

@@ -136,6 +136,7 @@ def test_new_test_class_default_suites(
             tap_class=factory.tap_class,
             config=factory.config,
             suite_config=None,
+            streams=None,
             parse_env_config=True,
         )
 
@@ -176,6 +177,7 @@ def test_new_test_class_custom_kwargs(
             tap_class=factory.tap_class,
             config=factory.config,
             suite_config=suite_config,
+            streams=None,
             parse_env_config=False,
             custom_kwarg=custom_kwarg,
         )
@@ -636,6 +638,7 @@ def test_get_tap_test_class(
             include_tap_tests=True,
             include_stream_tests=False,
             include_stream_attribute_tests=True,
+            streams=None,
             custom_kwarg="value",
         )
 

tests/core/testing/test_runners.py

@@ -175,8 +175,102 @@ def test_run_sync_dry_run(self, runner: TapTestRunner):
         assert result is True
         mock_tap.run_sync_dry_run.assert_called_once_with(
             dry_run_record_limit=runner.suite_config.max_records_limit,
+            streams=None,
         )
 
+    def test_init_with_streams_parameter(self, mock_tap_class):
+        """Test TapTestRunner initialization with streams parameter."""
+        config = {"test": "config"}
+        streams = ["users", "orders", "products"]
+
+        runner = TapTestRunner(
+            tap_class=mock_tap_class,
+            config=config,
+            streams=streams,
+        )
+
+        assert runner.streams == streams
+        assert runner.singer_class is mock_tap_class
+        assert runner.config == config
+
+    def test_init_with_streams_none(self, mock_tap_class):
+        """Test TapTestRunner initialization with streams=None."""
+        runner = TapTestRunner(
+            tap_class=mock_tap_class,
+            streams=None,
+        )
+
+        assert runner.streams is None
+
+    def test_init_with_streams_empty_sequence(self, mock_tap_class):
+        """Test TapTestRunner initialization with empty streams sequence."""
+        runner = TapTestRunner(
+            tap_class=mock_tap_class,
+            streams=[],
+        )
+
+        assert runner.streams == []
+
+    def test_run_sync_dry_run_with_streams(self, mock_tap_class):
+        """Test run_sync_dry_run method with streams parameter."""
+        streams = ["users", "orders"]
+        runner = TapTestRunner(
+            tap_class=mock_tap_class,
+            streams=streams,
+        )
+
+        mock_tap = Mock(spec=Tap)
+        mock_tap.run_sync_dry_run.return_value = True
+
+        with patch.object(runner, "new_tap", return_value=mock_tap):
+            result = runner.run_sync_dry_run()
+
+        assert result is True
+        mock_tap.run_sync_dry_run.assert_called_once_with(
+            dry_run_record_limit=runner.suite_config.max_records_limit,
+            streams=streams,
+        )
+
+    def test_run_sync_dry_run_with_tuple_streams(self, mock_tap_class):
+        """Test run_sync_dry_run method with tuple streams parameter."""
+        streams = ("users", "orders", "products")
+        runner = TapTestRunner(
+            tap_class=mock_tap_class,
+            streams=streams,
+        )
+
+        mock_tap = Mock(spec=Tap)
+        mock_tap.run_sync_dry_run.return_value = True
+
+        with patch.object(runner, "new_tap", return_value=mock_tap):
+            result = runner.run_sync_dry_run()
+
+        assert result is True
+        mock_tap.run_sync_dry_run.assert_called_once_with(
+            dry_run_record_limit=runner.suite_config.max_records_limit,
+            streams=streams,
+        )
+
+    def test_streams_parameter_with_other_kwargs(self, mock_tap_class):
+        """Test streams parameter works with other keyword arguments."""
+        config = {"api_key": "test"}
+        suite_config = SuiteConfig(max_records_limit=500)
+        streams = ["users"]
+        kwargs = {"parse_env_config": True}
+
+        runner = TapTestRunner(
+            tap_class=mock_tap_class,
+            config=config,
+            suite_config=suite_config,
+            streams=streams,
+            **kwargs,
+        )
+
+        assert runner.streams == streams
+        assert runner.config == config
+        assert runner.suite_config is suite_config
+        assert runner.default_kwargs == kwargs
+
     def test_clean_sync_output(self):
         """Test _clean_sync_output static method."""
         raw_output = """{"type": "SCHEMA", "stream": "test"}
@@ -535,6 +629,53 @@ def test_tap_runner_full_workflow(self):
         # Verify tap was created with correct config
         mock_tap_class.assert_called_with(config=config)
 
+    def test_tap_runner_with_streams_parameter(self):
+        """Test a complete tap runner workflow with streams parameter."""
+        # Create a minimal mock tap that behaves more realistically
+        mock_tap_class = Mock(spec=Tap)
+        mock_tap_instance = Mock(spec=Tap)
+        mock_tap_class.return_value = mock_tap_instance
+
+        # Configure realistic return values
+        mock_tap_instance.run_discovery.return_value = '{"streams": []}'
+        mock_tap_instance.run_connection_test.return_value = True
+        mock_tap_instance.run_sync_dry_run.return_value = True
+
+        config = {"api_key": "test_key"}
+        suite_config = SuiteConfig(max_records_limit=100)
+        streams = ["users", "orders"]
+
+        runner = TapTestRunner(
+            tap_class=mock_tap_class,
+            config=config,
+            suite_config=suite_config,
+            streams=streams,
+        )
+
+        # Test that streams are stored correctly
+        assert runner.streams == streams
+
+        # Test discovery (should not use streams)
+        catalog = runner.run_discovery()
+        assert catalog == '{"streams": []}'
+
+        # Test connection (should not use streams)
+        connection_ok = runner.run_connection_test()
+        assert connection_ok is True
+
+        # Test dry run (should pass streams parameter)
+        dry_run_ok = runner.run_sync_dry_run()
+        assert dry_run_ok is True
+
+        # Verify tap was created with correct config
+        mock_tap_class.assert_called_with(config=config)
+
+        # Verify that run_sync_dry_run was called with streams parameter
+        mock_tap_instance.run_sync_dry_run.assert_called_once_with(
+            dry_run_record_limit=100,
+            streams=streams,
+        )
+
     def test_target_runner_with_real_input_data(self, tmp_path: Path):
         """Test target runner with realistic input data."""
         # Create test input file