codeperl
diff --git a/‎localstack/aws/connect.py
Lines changed: 33 additions & 3 deletions b/‎localstack/aws/connect.py
Lines changed: 33 additions & 3 deletions
diff --git a/‎tests/unit/aws/test_connect.py
Lines changed: 36 additions & 1 deletion b/‎tests/unit/aws/test_connect.py
Lines changed: 36 additions & 1 deletion
@@ -9,7 +9,7 @@
 import re
 import threading
 from abc import ABC, abstractmethod
-from functools import cache, partial
+from functools import lru_cache, partial
 from typing import Any, Callable, Generic, Optional, TypedDict, TypeVar
 
 from boto3.session import Session
@@ -59,6 +59,36 @@ def my_patch(fn, self, **kwargs):
         return fn(self, **patched_kwargs)
 
 
+# patch the botocore.Config object to be comparable and hashable.
+# this solution does not validates the hashable (https://docs.python.org/3/glossary.html#term-hashable) definition on python
+# It would do so only when someone accesses the internals of the Config option to change the dict directly.
+# Since this is not a proper way to use the config object (but via config.merge), this should be fine
+def make_hash(o):
+    if isinstance(o, (set, tuple, list)):
+        return tuple([make_hash(e) for e in o])
+
+    elif not isinstance(o, dict):
+        return hash(o)
+
+    new_o = {}
+    for k, v in o.items():
+        new_o[k] = make_hash(v)
+
+    return hash(frozenset(sorted(new_o.items())))
+
+
+def config_equality_patch(self, other: object):
+    return type(self) == type(other) and self._user_provided_options == other._user_provided_options
+
+
+def config_hash_patch(self):
+    return make_hash(self._user_provided_options)
+
+
+Config.__eq__ = config_equality_patch
+Config.__hash__ = config_hash_patch
+
+
 def attribute_name_to_service_name(attribute_name):
     """
     Converts a python-compatible attribute name to the boto service name
@@ -314,10 +344,10 @@ def _get_client_post_hook(self, client: BaseClient) -> BaseClient:
         """
         return client
 
-    # TODO @cache here might result in a memory leak, as it keeps a reference to `self`
+    # TODO @lru_cache here might result in a memory leak, as it keeps a reference to `self`
     # We might need an alternative caching decorator with a weak ref to `self`
     # Otherwise factories might never be garbage collected
-    @cache
+    @lru_cache(maxsize=256)
     def _get_client(
         self,
         service_name: str,
 
@@ -3,6 +3,7 @@
 import boto3
 import botocore
 import pytest
+from botocore.config import Config
 
 from localstack.aws.api import RequestContext
 from localstack.aws.chain import Handler, HandlerChain
@@ -248,10 +249,44 @@ def test_client_caching(self):
         # TODO does it really make sense to test the caching?
         # TODO pretty ugly way of accessing the internal client
         factory = InternalClientFactory()
-        assert factory().s3._client == factory().s3._client
+        assert factory().s3._client is factory().s3._client
         factory_2 = InternalClientFactory()
         assert factory().s3._client != factory_2().s3._client
 
+    def test_client_caching_with_config(self):
+        """Test client caching. Same factory for the same service should result in the same client.
+        Different factories should result in different (identity wise) clients"""
+        # This test might get flaky if some internal boto3 caching is introduced at some point
+        config = Config(read_timeout=2, signature_version=botocore.UNSIGNED)
+        second_config = Config(read_timeout=2, signature_version=botocore.UNSIGNED)
+        third_config = Config(read_timeout=3, signature_version=botocore.UNSIGNED)
+        factory = InternalClientFactory()
+        client_1 = factory(config=config).s3._client
+        client_2 = factory(config=config).s3._client
+        client_3 = factory(config=second_config).s3._client
+        client_4 = factory(config=third_config).s3._client
+        assert client_1 is client_2
+        assert client_2 is client_3
+        assert client_3 is not client_4
+
+    def test_client_caching_with_merged_configs(self):
+        """Test client caching. Same factory for the same service should result in the same client.
+        Different factories should result in different (identity wise) clients"""
+        # This test might get flaky if some internal boto3 caching is introduced at some point
+        config_1 = Config(read_timeout=2)
+        config_2 = Config(signature_version=botocore.UNSIGNED)
+        config_3 = config_1.merge(config_2)
+        config_4 = config_1.merge(config_2)
+        factory = InternalClientFactory()
+        client_1 = factory(config=config_1).s3._client
+        client_2 = factory(config=config_2).s3._client
+        client_3 = factory(config=config_3).s3._client
+        client_4 = factory(config=config_4).s3._client
+        assert client_1 is not client_2
+        assert client_2 is not client_3
+        assert client_1 is not client_3
+        assert client_3 is client_4
+
     def test_internal_request_parameters(self, create_dummy_request_parameter_gateway):
         internal_dto = None