test(async-indexes): assert auto-resolve on cache miss (CI-0053)

Replaces the stale `test_async_index_factory_requires_prior_describe_rest_async`
(which expected PineconeValueError on cache miss) with
`test_async_index_factory_auto_resolves_on_cache_miss_rest_async`, which
verifies the new behavior introduced in ae44bf8:

- cache miss → describe() called → AsyncIndex returned
- cache is repopulated after auto-resolve
- after delete() polls index gone, cache miss → describe returns 404 → NotFoundError

Also removes the now-unused PineconeValueError import.

Aligns with unified-index-0024 (revised in harness claims/).

Author: jhamon

tests/integration/test_indexes_async.py

@@ -6,7 +6,6 @@
 
 from pinecone import AsyncIndex, AsyncPinecone
 from pinecone.errors import ForbiddenError
-from pinecone.errors.exceptions import PineconeValueError
 from pinecone.models.indexes.index import IndexModel, IndexSpec, IndexStatus
 from pinecone.models.indexes.specs import EmbedConfig, IntegratedSpec, ServerlessSpec
 from tests.integration.conftest import async_cleanup_resource, unique_name
@@ -533,25 +532,27 @@ async def test_configure_returns_none_and_preserves_deletion_protection_async(
 
 @pytest.mark.integration
 @pytest.mark.anyio
-async def test_async_index_factory_requires_prior_describe_rest_async(
+async def test_async_index_factory_auto_resolves_on_cache_miss_rest_async(
     async_client: AsyncPinecone,
 ) -> None:
-    """AsyncPinecone.index(name) raises PineconeValueError when host not cached;
-    works after describe(); raises again after delete() clears the cache.
+    """AsyncPinecone.index(name) auto-resolves the host via describe() on cache miss.
 
     Verifies claims:
     - unified-index-0020: Deleting an index removes that index's cached host URL.
-    - unified-index-0024: The async index client does not auto-fetch the host on
-      cache miss; it raises PineconeValueError instead.
+    - unified-index-0024: Both sync and async index clients auto-resolve via
+      describe() on cache miss; there is no asymmetry between the two.
 
     Sequence:
     1. Create index.
-    2. Call await async_client.index(name) — cache is empty → PineconeValueError.
-    3. Call await async_client.indexes.describe(name) — populates cache.
-    4. Call await async_client.index(name) — cache hit → returns AsyncIndex.
-    5. Delete the index (clears cache, waits for gone).
-    6. Call await async_client.index(name) — cache miss → PineconeValueError again.
+    2. Pop the host cache entry to simulate a cold-cache scenario.
+    3. Call await async_client.index(name) — cache miss → describe is called →
+       AsyncIndex returned; cache is repopulated.
+    4. Delete the index (clears cache, polls until gone).
+    5. Call await async_client.index(name) after deletion — describe returns 404
+       → NotFoundError raised.
     """
+    from pinecone.errors import NotFoundError
+
     name = unique_name("idx")
     deleted = False
     try:
@@ -565,32 +566,25 @@ async def test_async_index_factory_requires_prior_describe_rest_async(
         # create() with timeout polling already populated the cache via describe.
         # Clear it to simulate a cold-cache scenario for the factory test.
         async_client._host_cache.pop(name, None)
+        assert name not in async_client._host_cache
 
-        # Step 2: cache is empty — async factory raises instead of auto-fetching
-        # (unlike sync Pinecone.index() which triggers a new describe call)
-        with pytest.raises(PineconeValueError):
-            await async_client.index(name=name)
-
-        # Step 3: describe() populates the cache as a side effect
-        await async_client.indexes.describe(name)
-        assert name in async_client._host_cache, (
-            "Host must be cached after indexes.describe(name) (unified-index-0019)"
-        )
-
-        # Step 4: cache hit — factory succeeds
+        # Step 3: cache miss → auto-resolve via describe → AsyncIndex returned
         idx = await async_client.index(name=name)
         assert isinstance(idx, AsyncIndex)
+        assert name in async_client._host_cache, (
+            "Host must be cached after auto-resolve on cache miss (unified-index-0024)"
+        )
 
-        # Step 5: delete clears cache immediately and polls until gone
+        # Step 4: delete clears cache immediately and polls until gone
         await async_client.indexes.delete(name)
         deleted = True
 
         assert name not in async_client._host_cache, (
             "Host cache must be cleared after delete() (unified-index-0020)"
         )
 
-        # Step 6: cache miss again → PineconeValueError (no auto-describe in async)
-        with pytest.raises(PineconeValueError):
+        # Step 5: cache miss after delete → describe returns 404 → NotFoundError
+        with pytest.raises(NotFoundError):
             await async_client.index(name=name)
 
     finally: