streamsets 7.0.2__tar.gz → 7.0.3.dev1__tar.gz

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamsets
-Version: 7.0.2
+Version: 7.0.3.dev1
 Summary: A Python SDK for StreamSets
 Author: StreamSets Inc
 Classifier: Development Status :: 5 - Production/Stable

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/docs/run/jobs_instances.rst

@@ -326,6 +326,37 @@ These can be accessed using the `data_batch_count`, `idle_batch_count`, `input_r
     17535770
     17535770
 
+Retrieving Current Status With Metrics
+~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+By default, :py:attr:`streamsets.sdk.sch_models.Job.status` returns the current job status without record counts.
+To fetch the status and have the backend populate input, output, and error record counts from the timeseries service
+in a single API call, use the :py:attr:`streamsets.sdk.sch_models.Job.status_with_metrics` property instead.
+This is only meaningful for an actively running job, and requires that time series analysis is enabled on the job
+(``job.enable_time_series_analysis = True``):
+
+.. code-block:: python
+
+    job = sch.jobs.get(job_name='job name')
+
+    # Standard status — record counts are not populated
+    job.status
+
+    # Status with record counts populated from the timeseries service
+    status = job.status_with_metrics
+
+**Output:**
+
+.. code-block:: python
+
+    <JobStatus (status=ACTIVE, color=GREEN)>
+
+.. code-block:: python
+
+    status.input_record_count
+    status.output_record_count
+    status.error_record_count
+
 Balancing Data Collector instances
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/streamsets/sdk/__version__.py

@@ -2,4 +2,4 @@
 #  PID 5900-BAF
 #  Copyright StreamSets Inc., an IBM Company 2025
 
-__version__ = "7.0.2"
+__version__ = "7.0.3dev1"

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/streamsets/sdk/sch.py

@@ -23,6 +23,7 @@ from .constants import (
     SWAGGER_API_KEY, TRANSFORMER,
 )
 from .exceptions import EnginelessError, InitializationError, JobInactiveError, ValidationError
+from .retry import HTTPRetryError
 from .sch_models import (
     ActionAudits, AdminTool, Alert, ApiCredentialBuilder, ApiCredentials, AWSEnvironment, AzureEnvironment,
     AzureVMDeployment, ClassificationRuleBuilder, Configuration, Connection, ConnectionAudits, ConnectionBuilder,
@@ -159,16 +160,18 @@ class ControlHub:
         # We keep the Swagger API definitions as attributes for later use by various
         # builders.
         try:
-            self._connection_api = self._validate_api(api_dictionary=self.api_client.get_connection_api())
-            self._job_api = self._validate_api(api_dictionary=self.api_client.get_job_api())
-            self._pipelinestore_api = self._validate_api(api_dictionary=self.api_client.get_pipelinestore_api())
-            self._provisioning_api = self._validate_api(api_dictionary=self.api_client.get_provisioning_api())
-            self._security_api = self._validate_api(api_dictionary=self.api_client.get_security_api())
-            self._sequencing_api = self._validate_api(api_dictionary=self.api_client.get_sequencing_api())
-            self._topology_api = self._validate_api(api_dictionary=self.api_client.get_topology_api())
-            self._scheduler_api = self._validate_api(api_dictionary=self.api_client.get_scheduler_api())
-            self._notification_api = self._validate_api(api_dictionary=self.api_client.get_notification_api())
-            self._sla_api = self._validate_api(api_dictionary=self.api_client.get_sla_api())
+            self._connection_api = self._fetch_and_validate_api(self.api_client.get_connection_api, 'connection')
+            self._job_api = self._fetch_and_validate_api(self.api_client.get_job_api, 'job')
+            self._pipelinestore_api = self._fetch_and_validate_api(
+                self.api_client.get_pipelinestore_api, 'pipelinestore'
+            )
+            self._provisioning_api = self._fetch_and_validate_api(self.api_client.get_provisioning_api, 'provisioning')
+            self._security_api = self._fetch_and_validate_api(self.api_client.get_security_api, 'security')
+            self._sequencing_api = self._fetch_and_validate_api(self.api_client.get_sequencing_api, 'sequencing')
+            self._topology_api = self._fetch_and_validate_api(self.api_client.get_topology_api, 'topology')
+            self._scheduler_api = self._fetch_and_validate_api(self.api_client.get_scheduler_api, 'scheduler')
+            self._notification_api = self._fetch_and_validate_api(self.api_client.get_notification_api, 'notification')
+            self._sla_api = self._fetch_and_validate_api(self.api_client.get_sla_api, 'sla')
         except requests.exceptions.HTTPError as e:
             raise InitializationError(
                 "Error retrieving data. ControlHub cannot be initialized. Please try again."
@@ -194,6 +197,26 @@ class ControlHub:
             warnings.warn('ControlHub failed to initialize properly. You may have problems creating various objects')
         return api_dictionary
 
+    def _fetch_and_validate_api(self, fetch_func, api_name):
+        """Fetch an API definition, returning None and emitting a warning on 5xx HTTPRetryError.
+
+        Only 5xx responses where all retries have been exhausted are handled gracefully —
+        the service is considered temporarily unresponsive and initialization continues.
+        """
+        try:
+            return self._validate_api(api_dictionary=fetch_func())
+        except HTTPRetryError as e:
+            status_code = getattr(e.last_response, 'status_code', None)
+            if status_code is None or not (500 <= status_code < 600):
+                raise InitializationError(
+                    "Error retrieving data. ControlHub cannot be initialized. Please try again."
+                ) from e
+            warnings.warn(
+                f'ControlHub could not retrieve the {api_name} API definition ({type(e).__name__}: {e}). '
+                f'Operations that depend on this service may not work correctly.'
+            )
+            return None
+
     def _get_aster_api_client(self):
         # Allows us to retrieve an ApiClient from aster_api ad-hoc without having to instantiate one when we initialize
         # a ControlHub object.
@@ -4101,13 +4124,15 @@ class ControlHub:
             if engine_config['stageLibs']:
                 stage_libs = engine_config['stageLibs']
             elif engine_type == COLLECTOR:
-                stage_libs = DEFAULT_DATA_COLLECTOR_STAGE_LIBS
+                stage_libs = copy.deepcopy(DEFAULT_DATA_COLLECTOR_STAGE_LIBS)
             elif engine_type == TRANSFORMER:
-                stage_libs = DEFAULT_TRANSFORMER_STAGE_LIBS
+                stage_libs = copy.deepcopy(DEFAULT_TRANSFORMER_STAGE_LIBS)
             elif engine_type == SNOWPARK:
+                stage_libs = copy.deepcopy(DEFAULT_TRANSFORMER_SNOWFLAKE_STAGE_LIBS)
                 if Version('5.10.0') <= Version(engine_version):
-                    DEFAULT_TRANSFORMER_SNOWFLAKE_STAGE_LIBS.append('azure-keyvault-credentialstore')
-                stage_libs = DEFAULT_TRANSFORMER_SNOWFLAKE_STAGE_LIBS
+                    stage_libs.append('azure-keyvault-credentialstore')
+            else:
+                raise ValueError(f"Unknown {engine_type=}, should be one of {COLLECTOR}, {TRANSFORMER} or {SNOWPARK}")
 
             # Process the stage_libs
             processed_stage_libs = [

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/streamsets/sdk/sch_api.py

@@ -3262,16 +3262,24 @@ class ApiClient(object):
         response = self._post(app='jobrunner', endpoint='/v{}/jobs/status'.format(self.api_version), data=body)
         return Command(self, response)
 
-    def get_current_job_status(self, job_id):
+    def get_current_job_status(self, job_id, with_metrics=False):
         """Returns the current job status for given job id.
 
         Args:
             job_id (:obj:`str`)
+            with_metrics (:obj:`bool`, optional): When ``True``, the backend additionally fetches
+                metrics from the timeseries service and includes input/output/error record counts
+                in the response. Default: ``False``.
 
         Returns:
             An instance of :py:class:`streamsets.sdk.sch_api.Command`
         """
-        response = self._get(app='jobrunner', endpoint='/v{}/job/{}/currentStatus'.format(self.api_version, job_id))
+        params = {'withMetrics': with_metrics} if with_metrics else {}
+        response = self._get(
+            app='jobrunner',
+            endpoint='/v{}/job/{}/currentStatus'.format(self.api_version, job_id),
+            params=params,
+        )
         return Command(self, response)
 
     def get_all_jobs_status(self, organization, offset, len, with_wrapper=False):

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/streamsets/sdk/sch_models.py

@@ -413,13 +413,12 @@ class CollectionModel:
 
         1. Determine the total number of items that we need to fetch based on the ``len`` parameter (If not specified,
            assume infinite and fetch until ControlHub returns results).
-        2. Use the len(self) (which calls :py:meth:`streamsets.sdk.sch_api.ApiClient.get_pipelines_count`) as a source
-           of truth for the total number of pipelines existing in the ControlHub pipeline repository.
+        2. Use the API response's ``totalCount`` as the source of truth for the total number of items when the API supports pagination.
         3. Keep incrementing the offset with ``PAGE_LENGTH`` and query with new offset and ``PAGE_LENGTH`` until we
            reach requested number of items or we don't get any more items from ControlHub.
         4. While fetching these items in a loop, it is possible that some of the items are deleted by someone else
-           affecting the current offset we are using. To handle this, in the while loop, if the len(self) decreases, we
-           reduce the current offset by the number of items decreased (making sure, we aren't missing any items).
+           affecting the current offset we are using. To handle this, if the ``totalCount`` decreases, reduce the current offset
+           by the number of items deleted.
         5. In the list of items (order in which ControlHub returns the items), if the items that we already
            queried are deleted, the actual offset we have to use would reduce by the number of items deleted.
            On the otherhand, if
@@ -454,11 +453,11 @@ class CollectionModel:
         response, current_new_kwargs, class_type, class_kwargs = self._get_all_results_from_api(
             offset=current_offset, len=page_length, **kwargs_without_pagination_params
         )
-        previous_length = response['totalCount'] if is_api_paginable(response) else len(self)
 
         # If an API is paginated, the result set we need to page through will be contained in the response's 'data'
         # attribute. If there is no 'data' attribute, the response itself is the result set (unpaginated API).
         if is_api_paginable(response):
+            previous_length = response['totalCount']
             current_results = SeekableList(class_type(item, **class_kwargs) for item in response['data'])
         else:
             current_results = SeekableList(class_type(item, **class_kwargs) for item in response)
@@ -479,8 +478,12 @@ class CollectionModel:
             if len(all_ids) >= requested_length:
                 return
 
+            # If the API isn't paginated, we've already returned all available results.
+            if not is_api_paginable(response):
+                return
+
             current_offset += page_length
-            current_length = response['totalCount'] if is_api_paginable(response) else len(self)
+            current_length = response['totalCount']
             # If the total number of items decreased, reduce the offset by the difference to make sure we return all the
             # items. If duplicates occur in the process as described in step 5 of workflow in the docstring are handled
             # above by checking for the id in all_ids.
@@ -492,10 +495,7 @@ class CollectionModel:
                     )
                     current_offset = 0
             previous_length = current_length
-            # If the API we're paging over isn't enabled for pagination, break the loop after returning the first
-            # set of results to avoid an infinite loop.
-            if 'offset' not in response and 'len' not in response:
-                break
+
             logger.debug(
                 f'{self.__class__.__name__}. Fetching items with offset={current_offset} and len={page_length}'
             )
@@ -5883,6 +5883,19 @@ class Job(BaseModel):
         current_job_status = self._data['currentJobStatus']
         return JobStatus(current_job_status, self._control_hub) if current_job_status is not None else None
 
+    @property
+    def status_with_metrics(self):
+        """Current job status including input/output/error record counts from the timeseries service.
+
+        Fetches the current status with ``withMetrics=true``, which instructs the backend to
+        populate record counts in the response. Only meaningful for an actively running job.
+
+        Returns:
+            An instance of :py:class:`streamsets.sdk.sch_models.JobStatus`.
+        """
+        response = self._control_hub.api_client.get_current_job_status(self.id, with_metrics=True).response.json()
+        return JobStatus(response, self._control_hub)
+
     @property
     def history(self):
         """Status and run count history for the Job."""

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/streamsets/sdk/utils.py

@@ -44,6 +44,8 @@ SDC_DEFAULT_EXECUTION_MODE = 'STANDALONE'
 METERING_METRIC_LOOKUP = {'pipeline_hours': 'pipelineTime', 'clock_hours': 'clockTime', 'total_units': 'units'}
 
 # This is hardcoded in domainserver over here https://git.io/Jecwm
+# Legacy prefix used for DataCollector versions <= 7.8.x.
+# Versions >= 7.9.0 use a plain version string (e.g. "7.9.0") with no prefix.
 DEFAULT_JDK17_PREFIX = 'JDK17_'
 
 
@@ -206,7 +208,8 @@ class Version:
             # specifier `\w+` May or may not exist e.g. `RC2`
 
             try:
-                # Needed to make sure that JDK17 image versions are compared with JDK8 ones
+                # Needed to make sure that JDK17 image versions are compared with JDK8 ones for versions < 7.9.0
+                # Versions >= 7.9.0 already arrive without the prefix.
                 if isinstance(version, str) and version.startswith(DEFAULT_JDK17_PREFIX):
                     version = version[len(DEFAULT_JDK17_PREFIX) :]
 
@@ -496,7 +499,17 @@ class SeekableList(list):
         Returns:
             A :py:obj:`streamsets.sdk.utils.SeekableList` of results that match the supplied arguments.
         """
-        return SeekableList(i for i in self if all(getattr(i, k) == v for k, v in kwargs.items()))
+        if not kwargs:
+            return SeekableList(self)
+
+        results = SeekableList()
+        for item in self:
+            try:
+                if all(getattr(item, k) == v for k, v in kwargs.items()):
+                    results.append(item)
+            except HTTPError as e:
+                logger.warning('Skipping item during client-side filtering due to HTTP error: %s', e)
+        return results
 
 
 class MutableKwargs:

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/streamsets.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: streamsets
-Version: 7.0.2
+Version: 7.0.3.dev1
 Summary: A Python SDK for StreamSets
 Author: StreamSets Inc
 Classifier: Development Status :: 5 - Production/Stable

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/tests/integration/test_jobs.py

@@ -4,6 +4,7 @@
 
 # fmt: off
 import json
+import time
 import uuid
 
 import pytest
@@ -261,6 +262,30 @@ def test_job_templates_multiple_instances_counter(sch, simple_job_template):
             sch.delete_job(job)
 
 
+def test_start_job_template_does_not_fetch_job_count(sch, simple_job_template, monkeypatch):
+    jobs_count_requests = []
+    original_get = sch.api_client._get
+
+    def tracked_get(*args, **kwargs):
+        endpoint = kwargs.get('endpoint')
+        if endpoint and endpoint.endswith('/jobs/count'):
+            jobs_count_requests.append(endpoint)
+        return original_get(*args, **kwargs)
+
+    monkeypatch.setattr(sch.api_client, '_get', tracked_get)
+
+    jobs = []
+    try:
+        jobs = sch.start_job_template(simple_job_template, number_of_instances=3)
+
+        assert len(jobs) == 3
+        assert len(jobs_count_requests) == 0
+    finally:
+        for job in jobs:
+            sch.stop_job(job)
+            sch.delete_job(job)
+
+
 def test_job_templates_different_params_param_value(sch, simple_job_template):
     runtime_parameters = [{'x': '1', 'a': 'b'}, {'x': '2', 'a': 'b'}]
     jobs = sch.start_job_template(
@@ -412,6 +437,36 @@ def test_metrics(sch, sample_jobs):
         sch.stop_job(job)
 
 
+def test_status_with_metrics(sch, simple_pipeline, sch_engine_sdc_label, tmp_path):
+    job_builder = sch.get_job_builder()
+    job = job_builder.build('test_status_with_metrics_{}'.format(get_random_string()), pipeline=simple_pipeline)
+    job.data_collector_labels = sch_engine_sdc_label
+    job.enable_time_series_analysis = True
+    sch.add_job(job)
+
+    try:
+        sch.start_job(job)
+        try:
+            sch.wait_for_job_status(job, 'ACTIVE', timeout_sec=120)
+            time.sleep(60)  # allow timeseries metrics to populate before querying
+
+            status_without = sch.api_client.get_current_job_status(job.id, with_metrics=False).response.json()
+            (tmp_path / 'status_without_metrics.json').write_text(json.dumps(status_without, indent=2))
+
+            status_with = sch.api_client.get_current_job_status(job.id, with_metrics=True).response.json()
+            (tmp_path / 'status_with_metrics.json').write_text(json.dumps(status_with, indent=2))
+
+            # withMetrics=True on an active job should populate input or output record counts
+            assert status_with.get('inputRecordCount', 0) > 0 or status_with.get('outputRecordCount', 0) > 0
+            # without the flag, counts should be absent or zero
+            assert status_without.get('inputRecordCount', 0) == 0
+            assert status_without.get('outputRecordCount', 0) == 0
+        finally:
+            sch.stop_job(job)
+    finally:
+        sch.delete_job(job)
+
+
 def test_history(sch, sample_jobs):
     job = sample_jobs[0]
 

streamsets-7.0.3.dev1/tests/unit/test_jobs.py

@@ -0,0 +1,119 @@
+#  IBM Confidential
+#  PID 5900-BAF
+#  Copyright StreamSets Inc., an IBM Company 2024
+
+# fmt: off
+
+from copy import deepcopy
+from unittest.mock import MagicMock
+
+import pytest
+
+from streamsets.sdk.sch_models import Job, Jobs, JobStatus
+
+from .resources.jobs_data import DUMMY_JOB_JSON_1
+
+
+# fmt: on
+class MockApiClient:
+    def __init__(self):
+        self.get_current_job_status = MagicMock()
+
+
+class MockControlHub:
+    def __init__(self):
+        self.organization = "12345"
+        self.api_client = MockApiClient()
+
+
+@pytest.fixture(scope="function")
+def dummy_job():
+    json = deepcopy(DUMMY_JOB_JSON_1)
+    return Job(json, MockControlHub())
+
+
+def test_job_tag_supports_colons(dummy_job):
+    tag_name = 'test:colon'
+    dummy_job.add_tag(tag_name)
+    assert [tag.tag for tag in dummy_job.tags] == [tag_name]
+    dummy_job.remove_tag(tag_name)
+    assert not dummy_job.tags
+
+
+def test_status_with_metrics_calls_api_with_flag(dummy_job):
+    """Verify that status_with_metrics passes with_metrics=True to the API."""
+    status_data = deepcopy(DUMMY_JOB_JSON_1['currentJobStatus'])
+    status_data['inputRecordCount'] = 100
+    status_data['outputRecordCount'] = 95
+
+    mock_response = MagicMock()
+    mock_response.response.json.return_value = status_data
+    dummy_job._control_hub.api_client.get_current_job_status.return_value = mock_response
+
+    result = dummy_job.status_with_metrics
+
+    dummy_job._control_hub.api_client.get_current_job_status.assert_called_once_with(dummy_job.id, with_metrics=True)
+    assert isinstance(result, JobStatus)
+
+
+def test_get_current_job_status_without_metrics_omits_param():
+    """Verify that get_current_job_status does not send withMetrics when with_metrics=False."""
+    from unittest.mock import patch
+
+    from streamsets.sdk.sch_api import ApiClient
+
+    api_client = ApiClient.__new__(ApiClient)
+    api_client.api_version = 3
+
+    with patch.object(ApiClient, '_get', return_value=MagicMock()) as mock_get:
+        api_client.get_current_job_status('job-123', with_metrics=False)
+
+    _, call_kwargs = mock_get.call_args
+    assert not call_kwargs.get('params')
+
+
+def test_get_current_job_status_with_metrics_sends_param():
+    """Verify that get_current_job_status sends withMetrics=True when with_metrics=True."""
+    from unittest.mock import patch
+
+    from streamsets.sdk.sch_api import ApiClient
+
+    api_client = ApiClient.__new__(ApiClient)
+    api_client.api_version = 3
+
+    with patch.object(ApiClient, '_get', return_value=MagicMock()) as mock_get:
+        api_client.get_current_job_status('job-123', with_metrics=True)
+
+    _, call_kwargs = mock_get.call_args
+    assert call_kwargs.get('params') == {'withMetrics': True}
+
+
+def test_jobs_get_by_id_does_not_call_get_jobs_count():
+    """Verify that jobs.get(id=...) does not call the jobs/count endpoint."""
+    control_hub = MagicMock()
+    control_hub.api_client.get_jobs_count = MagicMock()
+
+    job_data = deepcopy(DUMMY_JOB_JSON_1)
+
+    response = {
+        'data': [job_data],
+        'totalCount': 1,
+        'offset': 0,
+        'len': 1,
+    }
+
+    jobs = Jobs(control_hub)
+
+    jobs._get_all_results_from_api = MagicMock(
+        return_value=(
+            response,
+            {},
+            Job,
+            {'control_hub': control_hub},
+        )
+    )
+
+    result = jobs.get(id=job_data['id'])
+
+    assert result.id == job_data['id']
+    control_hub.api_client.get_jobs_count.assert_not_called()

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/tests/unit/test_sch.py

@@ -5,10 +5,14 @@ import copy
 
 # fmt: off
 from copy import deepcopy
+from unittest.mock import MagicMock
 
 import pytest
+import requests
 
 from streamsets.sdk import ControlHub
+from streamsets.sdk.exceptions import InitializationError
+from streamsets.sdk.retry import HTTPRetryError
 from streamsets.sdk.sch_api import ApiClient
 from streamsets.sdk.sch_models import KubernetesDeployment, SelfManagedDeployment
 
@@ -229,3 +233,59 @@ def test_stop_deployment_with_force_k8s_calls_force(dummy_deployment_data, caplo
     assert any((_id == dep_id and state == "DEACTIVATION_ERROR") for (_id, state) in sch.api_client._wait_calls)
 
     assert isinstance(result, MockCommand)
+
+
+class _BareControlHub(ControlHub):
+    """ControlHub with __init__ skipped — lets us call instance methods directly."""
+
+    def __init__(self):
+        pass
+
+
+def test_fetch_and_validate_api_success():
+    sch = _BareControlHub()
+    api_dict = {'swagger': '2.0'}
+    assert sch._fetch_and_validate_api(lambda: api_dict, 'test') is api_dict
+
+
+@pytest.mark.parametrize('status_code', [500, 502, 503, 504])
+def test_fetch_and_validate_api_5xx_retry_error_returns_none(recwarn, status_code):
+    """5xx HTTPRetryError (service unresponsive after all retries) → warn + return None."""
+    mock_response = MagicMock()
+    mock_response.status_code = status_code
+
+    def _raise_retry_error():
+        raise HTTPRetryError(f'Max retries (3) exceeded for HTTP {status_code}', last_response=mock_response)
+
+    sch = _BareControlHub()
+    result = sch._fetch_and_validate_api(_raise_retry_error, 'sequencing')
+
+    assert result is None
+    assert len(recwarn) == 1
+    assert 'sequencing' in str(recwarn[0].message)
+    assert 'HTTPRetryError' in str(recwarn[0].message)
+
+
+@pytest.mark.parametrize('status_code', [400, 401, 403, 404, 429])
+def test_fetch_and_validate_api_non_5xx_retry_error_raises_initialization_error(status_code):
+    """Non-5xx HTTPRetryError must raise InitializationError with the original message."""
+    mock_response = MagicMock()
+    mock_response.status_code = status_code
+
+    def _raise_retry_error():
+        raise HTTPRetryError(f'Max retries (3) exceeded for HTTP {status_code}', last_response=mock_response)
+
+    sch = _BareControlHub()
+    with pytest.raises(InitializationError):
+        sch._fetch_and_validate_api(_raise_retry_error, 'test')
+
+
+def test_fetch_and_validate_api_http_error_propagates():
+    """requests.exceptions.HTTPError (not wrapped by retry) must propagate — not be swallowed."""
+
+    def _raise_http_error():
+        raise requests.exceptions.HTTPError('401 Unauthorized')
+
+    sch = _BareControlHub()
+    with pytest.raises(requests.exceptions.HTTPError):
+        sch._fetch_and_validate_api(_raise_http_error, 'test')

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/tests/unit/test_seekable_list.py

@@ -4,6 +4,7 @@
 
 # fmt: off
 import pytest
+from requests.exceptions import HTTPError
 
 from streamsets.sdk.utils import SeekableList
 
@@ -16,6 +17,17 @@ class Helper:
         self.name = helper_name
 
 
+class HelperWithBrokenName(Helper):
+    """Simulates a lazily-loaded object whose data fetch returns HTTP 400."""
+
+    def __init__(self, helper_id):
+        self.id = helper_id
+
+    @property
+    def name(self):
+        raise HTTPError('400: item was concurrently deleted')
+
+
 @pytest.fixture(autouse=True)
 def helper_object_list():
     return [Helper(helper_id=uid, helper_name=name) for uid, name in zip(range(1, 3), ['John', 'Jane', 'Alice'])]
@@ -62,6 +74,28 @@ def test_get_all_invalid_input(helper_object_list):
     assert len(result) == 0
 
 
+def test_get_all_skips_item_with_http_error_and_returns_matching_item():
+    """A concurrent deletion (HTTP 400) on one item must not abort the search for others."""
+    broken = HelperWithBrokenName(helper_id=99)
+    target = Helper(helper_id=3, helper_name='Alice')
+    seekable_list = SeekableList([broken, target])
+
+    result = seekable_list.get_all(name='Alice')
+
+    assert isinstance(result, SeekableList)
+    assert len(result) == 1
+    assert result[0].name == 'Alice'
+
+
+def test_get_all_returns_empty_list_when_all_items_raise_http_error():
+    seekable_list = SeekableList([HelperWithBrokenName(helper_id=i) for i in range(3)])
+
+    result = seekable_list.get_all(name='anything')
+
+    assert isinstance(result, SeekableList)
+    assert len(result) == 0
+
+
 def test_cast_seekable_to_list(helper_object_list):
     seekable_list = SeekableList(helper_object_list)
     casted_list = list(seekable_list)

{streamsets-7.0.2 → streamsets-7.0.3.dev1}/tox.ini

@@ -4,6 +4,7 @@ color = true
 envlist = unit-310, unit-311, unit-312, integration-310, integration-312, docs, install-{310,311,312}, jenkinsfile
 
 [testenv]
+package = wheel
 deps = pytest
        pytest-cov
        pytest-mock

streamsets-7.0.2/tests/unit/test_jobs.py

@@ -1,33 +0,0 @@
-#  IBM Confidential
-#  PID 5900-BAF
-#  Copyright StreamSets Inc., an IBM Company 2024
-
-# fmt: off
-
-from copy import deepcopy
-
-import pytest
-
-from streamsets.sdk.sch_models import Job
-
-from .resources.jobs_data import DUMMY_JOB_JSON_1
-
-
-# fmt: on
-class MockControlHub:
-    def __init__(self):
-        self.organization = "12345"
-
-
-@pytest.fixture(scope="function")
-def dummy_job():
-    json = deepcopy(DUMMY_JOB_JSON_1)
-    return Job(json, MockControlHub())
-
-
-def test_job_tag_supports_colons(dummy_job):
-    tag_name = 'test:colon'
-    dummy_job.add_tag(tag_name)
-    assert [tag.tag for tag in dummy_job.tags] == [tag_name]
-    dummy_job.remove_tag(tag_name)
-    assert not dummy_job.tags