rename idem_tok -> idempotency_key

tests/unit/providers/batches/test_reference_idempotency.py

@@ -8,14 +8,14 @@
 Tests for idempotency functionality in the reference batches provider.
 
 This module tests the optional idempotency feature that allows clients to provide
-an idempotency token (idem_tok) to ensure that repeated requests with the same token
-and parameters return the same batch, while requests with the same token but different
+an idempotency key (idempotency_key) to ensure that repeated requests with the same key
+and parameters return the same batch, while requests with the same key but different
 parameters result in a conflict error.
 
 Test Categories:
-1. Core Idempotency: Same parameters with same token return same batch
-2. Parameter Independence: Different parameters without tokens create different batches
-3. Conflict Detection: Same token with different parameters raises ConflictError
+1. Core Idempotency: Same parameters with same key return same batch
+2. Parameter Independence: Different parameters without keys create different batches
+3. Conflict Detection: Same key with different parameters raises ConflictError
 
 Tests by Category:
 
@@ -24,20 +24,20 @@ Tests by Category:
    - test_idempotent_batch_creation_metadata_order_independence
 
 2. Parameter Independence:
-   - test_non_idempotent_behavior_without_token
-   - test_different_idempotency_tokens_create_different_batches
+   - test_non_idempotent_behavior_without_key
+   - test_different_idempotency_keys_create_different_batches
 
 3. Conflict Detection:
-   - test_same_idem_tok_different_params_conflict (parametrized: input_file_id, metadata values, metadata None vs {})
+   - test_same_idempotency_key_different_params_conflict (parametrized: input_file_id, metadata values, metadata None vs {})
 
 Key Behaviors Tested:
-- Idempotent batch creation when idem_tok provided with identical parameters
+- Idempotent batch creation when idempotency_key provided with identical parameters
 - Metadata order independence for consistent batch ID generation
-- Non-idempotent behavior when no idem_tok provided (random UUIDs)
-- Conflict detection for parameter mismatches with same idempotency token
-- Deterministic ID generation based solely on idempotency token
-- Proper error handling with detailed conflict messages including token and error codes
-- Protection against idempotency token reuse with different request parameters
+- Non-idempotent behavior when no idempotency_key provided (random UUIDs)
+- Conflict detection for parameter mismatches with same idempotency key
+- Deterministic ID generation based solely on idempotency key
+- Proper error handling with detailed conflict messages including key and error codes
+- Protection against idempotency key reuse with different request parameters
 """
 
 import asyncio
@@ -51,14 +51,14 @@ class TestReferenceBatchesIdempotency:
     """Test suite for idempotency functionality in the reference implementation."""
 
     async def test_idempotent_batch_creation_same_params(self, provider, sample_batch_data):
-        """Test that creating batches with identical parameters returns the same batch when idem_tok is provided."""
+        """Test that creating batches with identical parameters returns the same batch when idempotency_key is provided."""
 
         del sample_batch_data["metadata"]
 
         batch1 = await provider.create_batch(
             **sample_batch_data,
             metadata={"test": "value1", "other": "value2"},
-            idem_tok="unique-token-1",
+            idempotency_key="unique-token-1",
         )
 
         # sleep for 1 second to allow created_at timestamps to be different
@@ -67,7 +67,7 @@ class TestReferenceBatchesIdempotency:
         batch2 = await provider.create_batch(
             **sample_batch_data,
             metadata={"other": "value2", "test": "value1"},  # Different order
-            idem_tok="unique-token-1",
+            idempotency_key="unique-token-1",
         )
 
         assert batch1.id == batch2.id
@@ -75,20 +75,32 @@ class TestReferenceBatchesIdempotency:
         assert batch1.metadata == batch2.metadata
         assert batch1.created_at == batch2.created_at
 
-    async def test_different_idempotency_tokens_create_different_batches(self, provider, sample_batch_data):
-        """Test that different idempotency tokens create different batches even with same params."""
+    async def test_different_idempotency_keys_create_different_batches(self, provider, sample_batch_data):
+        """Test that different idempotency keys create different batches even with same params."""
         batch1 = await provider.create_batch(
             **sample_batch_data,
-            idem_tok="token-A",
+            idempotency_key="token-A",
         )
 
         batch2 = await provider.create_batch(
             **sample_batch_data,
-            idem_tok="token-B",
+            idempotency_key="token-B",
         )
 
         assert batch1.id != batch2.id
 
+    async def test_non_idempotent_behavior_without_key(self, provider, sample_batch_data):
+        """Test that batches without idempotency key create unique batches even with identical parameters."""
+        batch1 = await provider.create_batch(**sample_batch_data)
+
+        batch2 = await provider.create_batch(**sample_batch_data)
+
+        assert batch1.id != batch2.id
+        assert batch1.input_file_id == batch2.input_file_id
+        assert batch1.endpoint == batch2.endpoint
+        assert batch1.completion_window == batch2.completion_window
+        assert batch1.metadata == batch2.metadata
+
     @pytest.mark.parametrize(
         "param_name,first_value,second_value",
         [
@@ -97,17 +109,17 @@ class TestReferenceBatchesIdempotency:
             ("metadata", None, {}),
         ],
     )
-    async def test_same_idem_tok_different_params_conflict(
+    async def test_same_idempotency_key_different_params_conflict(
         self, provider, sample_batch_data, param_name, first_value, second_value
     ):
-        """Test that same idem_tok with different parameters raises conflict error."""
-        sample_batch_data["idem_tok"] = "same-token"
+        """Test that same idempotency_key with different parameters raises conflict error."""
+        sample_batch_data["idempotency_key"] = "same-token"
 
         sample_batch_data[param_name] = first_value
 
         batch1 = await provider.create_batch(**sample_batch_data)
 
-        with pytest.raises(ConflictError, match="Idempotency token.*was previously used with different parameters"):
+        with pytest.raises(ConflictError, match="Idempotency key.*was previously used with different parameters"):
             sample_batch_data[param_name] = second_value
             await provider.create_batch(**sample_batch_data)