Update config_store to use generated exceptions

Also, use larger buffer size rather than doing
unecessary resizes and address a few other comments
from the PR.

Author: posborne

examples/config-store/config-store.py

@@ -52,16 +52,6 @@ def test_get(store_name, key, default=None):
     return {"value": value}
 
 
-@app.route("/get_with_initial_buf_len/<store_name>/<key>/<initial_buf_len:int>")
-@handle_request
-def test_get_with_initial_buf_len(store_name, key, initial_buf_len):
-    """Proxy endpoint to test get with custom initial_buf_len using raw API."""
-    config = ConfigStore.open(store_name)
-    # Use _get_raw to test buffer sizing without automatic retry
-    value = config._get_raw(key, initial_buf_len)
-    return {"value": value}
-
-
 @app.route("/contains/<store_name>/<key>")
 @handle_request
 def test_contains(store_name, key):

fastly_compute/config_store.py

@@ -12,42 +12,10 @@
 """
 
 from wit_world.imports import config_store as wit_config_store
-from wit_world.imports.types import Error_BufferLen, Error_InvalidArgument, OpenError
 
-from fastly_compute.exceptions import FastlyError, remap_wit_errors
-
-
-class ConfigStoreError(FastlyError):
-    """Base exception for all config store errors."""
-
-
-class ConfigStoreNotFoundError(ConfigStoreError):
-    """The requested config store does not exist."""
-
-
-class ConfigStoreInvalidNameError(ConfigStoreError):
-    """The config store name is invalid."""
-
-
-class ConfigStoreBufferTooSmallError(ConfigStoreError):
-    """The buffer provided was too small for the config value.
-
-    The required buffer size is available in the `required_size` attribute.
-    """
-
-    def __init__(self, error: Error_BufferLen):
-        """Initialize with the WIT error containing the required size.
-
-        :param error: The WIT Error_BufferLen dataclass with the required size
-        """
-        self.required_size = error.value
-        super().__init__(
-            f"Buffer too small for config store value. Required size: {self.required_size} bytes"
-        )
-
-
-class ConfigStoreInvalidKeyError(ConfigStoreError):
-    """The key provided is invalid."""
+# The maximum value for a u64, used to signal that we don't want to cap
+# the length of values returned by the host.
+_MAX_U64 = 0xFFFFFFFFFFFFFFFF
 
 
 class ConfigStore:
@@ -67,21 +35,14 @@ def __init__(self, store: wit_config_store.Store):
         self._store = store
 
     @classmethod
-    @remap_wit_errors(
-        {
-            OpenError.NOT_FOUND: ConfigStoreNotFoundError,
-            OpenError.INVALID_SYNTAX: ConfigStoreInvalidNameError,
-            OpenError.NAME_TOO_LONG: ConfigStoreInvalidNameError,
-            OpenError.RESERVED: ConfigStoreInvalidNameError,
-        }
-    )
     def open(cls, name: str) -> "ConfigStore":
         """Open a config store by name.
 
         :param name: The name of the config store
         :return: ConfigStore instance
-        :raises ConfigStoreNotFoundError: If the config store doesn't exist
-        :raises ConfigStoreInvalidNameError: If the name is invalid or too long
+        :raises ~fastly_compute.exceptions.types.open_error.NotFound: If the config store doesn't exist
+        :raises ~fastly_compute.exceptions.types.open_error.InvalidSyntax: If the name is invalid
+        :raises ~fastly_compute.exceptions.types.open_error.NameTooLong: If the name is too long
 
         Example::
 
@@ -90,91 +51,39 @@ def open(cls, name: str) -> "ConfigStore":
         store = wit_config_store.Store.open(name)
         return cls(store)
 
-    def get(
-        self, key: str, default: str | None = None, initial_buf_len: int = 1024
-    ) -> str | None:
-        """Get a configuration value with automatic buffer resizing.
-
-        This method automatically handles buffer sizing for config store values.
-        If the initial buffer is too small, it will automatically retry once with
-        the exact size required by the host.
+    def get(self, key: str, default: str | None = None) -> str | None:
+        """Get a configuration value.
 
         :param key: The configuration key
         :param default: Default value if key not found
-        :param initial_buf_len: Initial buffer size hint in bytes (default: 1024).
-            This can be tuned for performance if you know your values are typically
-            larger or smaller than 1KB.
         :return: Configuration value or default if not found
-        :raises ConfigStoreInvalidKeyError: If the key is invalid
-        :raises ConfigStoreBufferTooSmallError: If the value is too large even after
-            automatic resizing (should not happen unless there's a host-level bug)
+        :raises ~fastly_compute.exceptions.types.error.InvalidArgument: If the key is invalid
 
         Example::
 
             config = ConfigStore.open("app-config")
-            # Basic usage with default buffer size
             api_url = config.get("api_url", "https://api.example.com")
-
-            # Optimize for large values by using a larger initial buffer
-            large_value = config.get("large_config", initial_buf_len=16384)
         """
-        # Try with the initial buffer size
-        try:
-            result = self._get_raw(key, initial_buf_len)
-        except ConfigStoreBufferTooSmallError as e:
-            # Buffer was too small. The exception contains the exact required size.
-            # Retry ONCE with the exact size needed. If this second attempt fails,
-            # let the exception propagate (no infinite recursion).
-            result = self._get_raw(key, e.required_size)
-
+        result = self._store.get(key, _MAX_U64)
         if result is None:
             result = default
 
         return result
 
-    @remap_wit_errors(
-        {
-            Error_BufferLen: ConfigStoreBufferTooSmallError,
-            Error_InvalidArgument: ConfigStoreInvalidKeyError,
-        }
-    )
-    def _get_raw(self, key: str, max_len: int) -> str | None:
-        """Internal method to get a value with a specific buffer size.
-
-        :param key: The configuration key
-        :param max_len: Maximum buffer length
-        :return: Configuration value or None if not found
-        :raises ConfigStoreBufferTooSmallError: If the buffer is too small
-        :raises ConfigStoreInvalidKeyError: If the key is invalid
-        """
-        return self._store.get(key, max_len)
-
     def contains(self, key: str) -> bool:
         """Check if a key exists in the config store.
 
-        Uses a zero-length buffer to efficiently check for key existence without
-        retrieving the value.
-
         :param key: The configuration key
         :return: True if the key exists, False otherwise
-        :raises ConfigStoreInvalidKeyError: If the key is invalid
+        :raises ~fastly_compute.exceptions.types.error.InvalidArgument: If the key is invalid
 
         Example::
 
             config = ConfigStore.open("app-config")
             if config.contains("feature_flag"):
                 print("Feature flag exists")
         """
-        try:
-            # Use a 0-length buffer to check existence without retrieving the value
-            result = self._get_raw(key, 0)
-            return result is not None
-        except ConfigStoreBufferTooSmallError:
-            # Buffer too small means the key exists with a non-empty value
-            return True
-        except ConfigStoreInvalidKeyError:
-            # Re-raise invalid key errors
-            raise
+        return self.get(key) is not None
 
     def close(self) -> None:
         """Explicitly close the config store, releasing its resources.
@@ -196,5 +105,10 @@ def __enter__(self) -> "ConfigStore":
         return self
 
     def __exit__(self, exc_type, exc_val, exc_tb):
-        """Context manager exit."""
-        self._store.__exit__(exc_type, exc_val, exc_tb)
+        """Context manager exit.
+
+        Use of the context manager will free up the underlying host resource on
+        exit. Referencing the resource after context manager exit will result in
+        a trap.
+        """
+        self.close()

tests/test_config_store.py

@@ -19,7 +19,7 @@ class TestConfigStore(ViceroyTestBase):
                         "whitespace": "   ",
                         "special_chars": "!@#$%^&*()",
                         "unicode": "Hello 世界 🌍",
-                        "large_value": "x" * 100,  # 100 byte value for buffer tests
+                        "large_value": "x" * 8000,  # 8000 byte value for buffer tests
                     },
                 }
             }
@@ -52,7 +52,7 @@ def test_open_nonexistent_store(self):
         response = self.get("/get/nonexistent/key")
         assert response.status_code == 500
         data = response.json()
-        assert data["error_type"] == "ConfigStoreNotFoundError"
+        assert data["error_type"] == "NotFound"
 
     def test_get_string_value(self):
         """Test getting a string value."""
@@ -84,20 +84,9 @@ def test_unicode_support(self):
         """Test handling of unicode characters."""
         self.assert_get_value("test-config", "unicode", "Hello 世界 🌍")
 
-    def test_automatic_buffer_resize_for_large_values(self):
-        """Test that automatic buffer resizing handles large values."""
-        # The large_value is 100 bytes. With automatic resizing, this should work
-        # even with a small initial buffer (default 1024 bytes).
-        self.assert_get_value("test-config", "large_value", "x" * 100)
-
-    def test_buffer_too_small_with_raw_api(self):
-        """Test that _get_raw API can still raise buffer errors when called directly."""
-        # The /get_with_initial_buf_len endpoint uses a small buffer without retry
-        # to test that buffer errors can still occur at the lower level
-        response = self.get("/get_with_initial_buf_len/test-config/large_value/10")
-        assert response.status_code == 500
-        data = response.json()
-        assert data["error_type"] == "ConfigStoreBufferTooSmallError"
+    def test_large_values(self):
+        """Test that large values are handled correctly."""
+        self.assert_get_value("test-config", "large_value", "x" * 8000)
 
     def test_contains_existing_key(self):
         """Test that contains returns True for existing keys."""