airbyte_api.errors.sdkerror.SDKError: API error occurred: Status 500
{"status":500,"type":"https://reference.airbyte.com/reference/errors","title":"unexpected-problem","detail":"An unexpected problem has occurred. If this is an error that needs to be addressed, please submit a pull request or github issue.","documentationUrl":null,"data":{"message":"Secret reference 9d209155-b1c6-45a9-8982-e6443c2f386a does not exist but is referenced in the config"}}
workspace_id = '19d7a891-8e0e-40ac-8a8c-5faf8d11e47c'
airbyte_cloud_api_root = 'https://api.airbyte.com/v1'
airbyte_cloud_client_id = <SecretString: ****>
airbyte_cloud_client_secret = <SecretString: ****>

    def test_list_destinations(
        workspace_id: str,
        airbyte_cloud_api_root: str,
        airbyte_cloud_client_id: SecretString,
        airbyte_cloud_client_secret: SecretString,
    ) -> None:
>       result: list[DestinationResponse] = api_util.list_destinations(
            workspace_id=workspace_id,
            api_root=airbyte_cloud_api_root,
            client_id=airbyte_cloud_client_id,
            client_secret=airbyte_cloud_client_secret,
        )

tests/integration_tests/cloud/test_cloud_api_util.py:87: 
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 
airbyte/_util/api_util.py:306: in list_destinations
    response = airbyte_instance.destinations.list_destinations(
_ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ _ 

self = <airbyte_api.destinations.Destinations object at 0x7fb60c1515d0>
request = ListDestinationsRequest(include_deleted=False, limit=100, offset=300, workspace_ids=['19d7a891-8e0e-40ac-8a8c-5faf8d11e47c'])

    def list_destinations(self, request: api.ListDestinationsRequest) -> api.ListDestinationsResponse:
        r"""List destinations"""
        hook_ctx = HookContext(operation_id='listDestinations', oauth2_scopes=[], security_source=self.sdk_configuration.security)
        base_url = utils.template_url(*self.sdk_configuration.get_server_details())
    
        url = base_url + '/destinations'
    
        if callable(self.sdk_configuration.security):
            headers, query_params = utils.get_security(self.sdk_configuration.security())
        else:
            headers, query_params = utils.get_security(self.sdk_configuration.security)
    
        query_params = { **utils.get_query_params(request), **query_params }
        headers['Accept'] = 'application/json'
        headers['user-agent'] = self.sdk_configuration.user_agent
        client = self.sdk_configuration.client
    
        try:
            req = client.prepare_request(requests_http.Request('GET', url, params=query_params, headers=headers))
            req = self.sdk_configuration.get_hooks().before_request(BeforeRequestContext(hook_ctx), req)
            http_res = client.send(req)
        except Exception as e:
            _, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), None, e)
            if e is not None:
                raise e
    
        if utils.match_status_codes(['403','404','4XX','5XX'], http_res.status_code):
            result, e = self.sdk_configuration.get_hooks().after_error(AfterErrorContext(hook_ctx), http_res, None)
            if e is not None:
                raise e
            if result is not None:
                http_res = result
        else:
            http_res = self.sdk_configuration.get_hooks().after_success(AfterSuccessContext(hook_ctx), http_res)
    
    
    
        res = api.ListDestinationsResponse(status_code=http_res.status_code, content_type=http_res.headers.get('Content-Type') or '', raw_response=http_res)
    
        if http_res.status_code == 200:
            # pylint: disable=no-else-return
            if utils.match_content_type(http_res.headers.get('Content-Type') or '', 'application/json'):
                out = utils.unmarshal_json(http_res.text, Optional[models.DestinationsResponse])
                res.destinations_response = out
            else:
                content_type = http_res.headers.get('Content-Type')
                raise errors.SDKError(f'unknown content-type received: {content_type}', http_res.status_code, http_res.text, http_res)
        elif http_res.status_code == 403 or http_res.status_code == 404 or http_res.status_code >= 400 and http_res.status_code < 500 or http_res.status_code >= 500 and http_res.status_code < 600:
>           raise errors.SDKError('API error occurred', http_res.status_code, http_res.text, http_res)
E           airbyte_api.errors.sdkerror.SDKError: API error occurred: Status 500
E           {"status":500,"type":"https://reference.airbyte.com/reference/errors","title":"unexpected-problem","detail":"An unexpected problem has occurred. If this is an error that needs to be addressed, please submit a pull request or github issue.","documentationUrl":null,"data":{"message":"Secret reference 9d209155-b1c6-45a9-8982-e6443c2f386a does not exist but is referenced in the config"}}

.venv/lib/python3.10/site-packages/airbyte_api/destinations.py:229: SDKError

AssertionError: expected call not found.
Expected: _execute_sql('\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP WITH TIME ZONE,\n  "updated_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_meta" JSON\n        )\n        \n        ')
Actual: _execute_sql('\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP,\n  "updated_at" TIMESTAMP,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP,\n  "_airbyte_meta" JSON\n        )\n        \n        ')

pytest introspection follows:

Args:
assert ('\n        C... \n        ',) == ('\n        C... \n        ',)
  
  At index 0 diff: '\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP,\n  "updated_at" TIMESTAMP,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP,\n  "_airbyte_meta" JSON\n        )\n        \n        ' != '\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP WITH TIME ZONE,\n  "updated_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_meta" JSON\n        )\n        \n        '
  
  Full diff:
    (
        '\n'
        '        CREATE TABLE airbyte."products" (\n'
        '            "id" BIGINT,\n'
        '  "make" VARCHAR,\n'
        '  "model" VARCHAR,\n'
        '  "year" BIGINT,\n'
        '  "price" DECIMAL(38, 9),\n'
  -     '  "created_at" TIMESTAMP WITH TIME ZONE,\n'
  ?                              ---------------
  +     '  "created_at" TIMESTAMP,\n'
  -     '  "updated_at" TIMESTAMP WITH TIME ZONE,\n'
  ?                              ---------------
  +     '  "updated_at" TIMESTAMP,\n'
        '  "_airbyte_raw_id" VARCHAR,\n'
  -     '  "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,\n'
  ?                                         ---------------
  +     '  "_airbyte_extracted_at" TIMESTAMP,\n'
        '  "_airbyte_meta" JSON\n'
        '        )\n'
        '        \n'
        '        ',
    )
self = <MagicMock name='_execute_sql' id='140417432321328'>
args = ('\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "yea...VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_meta" JSON\n        )\n        \n        ',)
kwargs = {}
expected = call('\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  ... VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_meta" JSON\n        )\n        \n        ')
actual = call('\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  ...airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP,\n  "_airbyte_meta" JSON\n        )\n        \n        ')
_error_message = <function NonCallableMock.assert_called_with.<locals>._error_message at 0x7fb57b263eb0>
cause = None

    def assert_called_with(self, /, *args, **kwargs):
        """assert that the last call was made with the specified arguments.
    
        Raises an AssertionError if the args and keyword args passed in are
        different to the last call to the mock."""
        if self.call_args is None:
            expected = self._format_mock_call_signature(args, kwargs)
            actual = 'not called.'
            error_message = ('expected call not found.\nExpected: %s\nActual: %s'
                    % (expected, actual))
            raise AssertionError(error_message)
    
        def _error_message():
            msg = self._format_mock_failure_message(args, kwargs)
            return msg
        expected = self._call_matcher(_Call((args, kwargs), two=True))
        actual = self._call_matcher(self.call_args)
        if actual != expected:
            cause = expected if isinstance(expected, Exception) else None
>           raise AssertionError(_error_message()) from cause
E           AssertionError: expected call not found.
E           Expected: _execute_sql('\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP WITH TIME ZONE,\n  "updated_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_meta" JSON\n        )\n        \n        ')
E           Actual: _execute_sql('\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP,\n  "updated_at" TIMESTAMP,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP,\n  "_airbyte_meta" JSON\n        )\n        \n        ')

/opt/hostedtoolcache/Python/3.10.18/x64/lib/python3.10/unittest/mock.py:929: AssertionError

During handling of the above exception, another exception occurred:

    @pytest.mark.slow
    def test_cache_columns_for_datetime_types_are_timezone_aware():
        """Ensures sql types are correctly converted to the correct sql timezone aware column types"""
        expected_sql = """
            CREATE TABLE airbyte."products" (
                "id" BIGINT,
      "make" VARCHAR,
      "model" VARCHAR,
      "year" BIGINT,
      "price" DECIMAL(38, 9),
      "created_at" TIMESTAMP WITH TIME ZONE,
      "updated_at" TIMESTAMP WITH TIME ZONE,
      "_airbyte_raw_id" VARCHAR,
      "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,
      "_airbyte_meta" JSON
            )
            \n        """
        source = get_source(
            name="source-faker",
            config={},
        )
    
        config = DuckDBConfig(
            schema_name="airbyte",
            db_path=":memory:",
        )
    
        processor = DuckDBSqlProcessor(
            catalog_provider=CatalogProvider(source.configured_catalog),
            temp_dir=Path(),
            temp_file_cleanup=True,
            sql_config=config,
        )
    
        with (
            patch.object(processor, "_execute_sql") as _execute_sql_mock,
        ):
            processor._ensure_final_table_exists(
                stream_name="products",
            )
>           _execute_sql_mock.assert_called_with(expected_sql)
E           AssertionError: expected call not found.
E           Expected: _execute_sql('\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP WITH TIME ZONE,\n  "updated_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_meta" JSON\n        )\n        \n        ')
E           Actual: _execute_sql('\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP,\n  "updated_at" TIMESTAMP,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP,\n  "_airbyte_meta" JSON\n        )\n        \n        ')
E           
E           pytest introspection follows:
E           
E           Args:
E           assert ('\n        C... \n        ',) == ('\n        C... \n        ',)
E             
E             At index 0 diff: '\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP,\n  "updated_at" TIMESTAMP,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP,\n  "_airbyte_meta" JSON\n        )\n        \n        ' != '\n        CREATE TABLE airbyte."products" (\n            "id" BIGINT,\n  "make" VARCHAR,\n  "model" VARCHAR,\n  "year" BIGINT,\n  "price" DECIMAL(38, 9),\n  "created_at" TIMESTAMP WITH TIME ZONE,\n  "updated_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_raw_id" VARCHAR,\n  "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,\n  "_airbyte_meta" JSON\n        )\n        \n        '
E             
E             Full diff:
E               (
E                   '\n'
E                   '        CREATE TABLE airbyte."products" (\n'
E                   '            "id" BIGINT,\n'
E                   '  "make" VARCHAR,\n'
E                   '  "model" VARCHAR,\n'
E                   '  "year" BIGINT,\n'
E                   '  "price" DECIMAL(38, 9),\n'
E             -     '  "created_at" TIMESTAMP WITH TIME ZONE,\n'
E             ?                              ---------------
E             +     '  "created_at" TIMESTAMP,\n'
E             -     '  "updated_at" TIMESTAMP WITH TIME ZONE,\n'
E             ?                              ---------------
E             +     '  "updated_at" TIMESTAMP,\n'
E                   '  "_airbyte_raw_id" VARCHAR,\n'
E             -     '  "_airbyte_extracted_at" TIMESTAMP WITH TIME ZONE,\n'
E             ?                                         ---------------
E             +     '  "_airbyte_extracted_at" TIMESTAMP,\n'
E                   '  "_airbyte_meta" JSON\n'
E                   '        )\n'
E                   '        \n'
E                   '        ',
E               )

tests/integration_tests/test_all_cache_types.py:331: AssertionError