update tests

Author: amber-yujueWang

sdk/cognitiveservices/azure-ai-speech-transcription/assets.json

@@ -1 +1 @@
-{"AssetsRepo":"Azure/azure-sdk-assets","AssetsRepoPrefixPath":"java","TagPrefix":"java/cognitiveservices/azure-ai-speech-transcription","Tag": "java/cognitiveservices/azure-ai-speech-transcription_5be01e978d"}
+{"AssetsRepo":"Azure/azure-sdk-assets","AssetsRepoPrefixPath":"java","TagPrefix":"java/cognitiveservices/azure-ai-speech-transcription","Tag": "java/cognitiveservices/azure-ai-speech-transcription_3b50d0dce8"}

sdk/cognitiveservices/azure-ai-speech-transcription/src/samples/java/com/azure/ai/speech/transcription/TranscribeMultiLanguageSample.java

@@ -100,7 +100,8 @@ public static void main(String[] args) {
 
             System.out.println("\nNote: When no locales are specified, the service transcribes all languages");
             System.out.println("present in the audio. However, the locale field in each phrase may not always");
-            System.out.println("accurately reflect the actual language of that specific phrase.");        } catch (Exception e) {
+            System.out.println("accurately reflect the actual language of that specific phrase.");
+        } catch (Exception e) {
             System.err.println("Error: " + e.getMessage());
             e.printStackTrace();
         }

sdk/cognitiveservices/azure-ai-speech-transcription/src/test/java/com/azure/ai/speech/transcription/README.md

@@ -6,9 +6,9 @@ This directory contains tests for the Azure AI Speech Transcription client libra
 
 The tests are organized as follows:
 
-- **TranscriptionClientTestBase.java**: Base class containing common test infrastructure, helper methods, and validation logic
-- **TranscriptionClientTest.java**: Tests for the synchronous `TranscriptionClient`
-- **TranscriptionAsyncClientTest.java**: Tests for the asynchronous `TranscriptionAsyncClient`
+- **TranscriptionClientTestBase.java**: Base class containing common test infrastructure, helper methods, and validation logic. Includes support for both file-based and URL-based transcription.
+- **TranscriptionClientTest.java**: Tests for the synchronous `TranscriptionClient` (14 tests)
+- **TranscriptionAsyncClientTest.java**: Tests for the asynchronous `TranscriptionAsyncClient` (16 tests)
 - **generated/**: Auto-generated test templates (for reference only)
 
 ## Prerequisites
@@ -47,7 +47,9 @@ export SPEECH_API_KEY="<your-api-key>"
 
 ## Configure Test Proxy
 
-The Azure SDK for Java uses a test proxy for recording and playing back HTTP interactions. Configure the test mode by setting the `AZURE_TEST_MODE` environment variable:
+The Azure SDK for Java uses a test proxy for recording and playing back HTTP interactions. This library has been migrated to use the test proxy following the [Test Proxy Migration Guide](https://github.com/Azure/azure-sdk-for-java/blob/main/eng/common/testproxy/README.md).
+
+Test recordings are stored in the [azure-sdk-assets](https://github.com/Azure/azure-sdk-assets) repository and referenced via the `assets.json` file. Configure the test mode by setting the `AZURE_TEST_MODE` environment variable:
 
 ### Live Mode (against live service)
 
@@ -63,7 +65,11 @@ This mode makes real HTTP calls to the Azure service. Use this when you want to
 $env:AZURE_TEST_MODE = "RECORD"
 ```
 
-This mode makes real HTTP calls and records them for later playback. Recorded sessions are saved in the `session-records` directory.
+This mode makes real HTTP calls and records them for later playback. Recordings are managed by the test-proxy tool and can be pushed to the azure-sdk-assets repository using:
+
+```bash
+test-proxy push -a assets.json
+```
 
 ### Playback Mode (use recordings)
 
@@ -105,9 +111,10 @@ mvn test -Dtest=TranscriptionClientTest#testTranscribeSyncBasicFromFile
 
 ### Synchronous Tests (TranscriptionClientTest)
 
-Tests for the synchronous `TranscriptionClient`, including:
+Tests for the synchronous `TranscriptionClient` (14 tests), including:
 
 - Basic transcription from file
+- Transcription from URL (using publicly accessible audio URL)
 - Transcription with language specification
 - Transcription with multiple languages
 - Transcription with speaker diarization
@@ -118,7 +125,11 @@ Tests for the synchronous `TranscriptionClient`, including:
 
 ### Asynchronous Tests (TranscriptionAsyncClientTest)
 
-Tests for the asynchronous `TranscriptionAsyncClient`, mirroring the synchronous tests but using reactive programming patterns with `Mono` and `Flux`.
+Tests for the asynchronous `TranscriptionAsyncClient` (16 tests), mirroring the synchronous tests but using reactive programming patterns with `Mono` and `Flux`. Includes additional tests for:
+
+- Transcription from URL (using publicly accessible audio URL)
+- Error handling with invalid language codes
+- Placeholder tests for empty audio data and cancellation scenarios
 
 ## Authentication
 
@@ -135,8 +146,9 @@ To test with token-based authentication, some tests use `createClient(false, tru
 
 1. **Missing environment variables**: Ensure `SPEECH_ENDPOINT` and `SPEECH_API_KEY` are set correctly
 2. **Missing sample audio file**: Make sure you have a `sample.wav` file in the test directory (WAV, MP3, or OGG format, shorter than 2 hours, smaller than 250 MB)
-3. **Test proxy issues**: If playback tests fail, try running in LIVE or RECORD mode first
-4. **Network issues**: Check your network connection and firewall settings
+3. **URL transcription failures**: URL-based transcription requires a specific API key tier that supports this feature. If URL tests fail with 401 errors, verify your Speech resource supports URL transcription.
+4. **Test proxy issues**: If playback tests fail, try running in LIVE or RECORD mode first to regenerate recordings
+5. **Network issues**: Check your network connection and firewall settings
 
 ### Enable Detailed Logging
 
@@ -158,15 +170,45 @@ $env:AZURE_LOG_LEVEL = "verbose"
 The current tests cover:
 
 - ✅ Client instantiation with different authentication methods
-- ✅ Basic transcription functionality
+- ✅ Basic transcription functionality from files
+- ✅ Transcription from publicly accessible URLs
 - ✅ Transcription with various options (language, diarization, profanity filter, timestamps)
 - ✅ Both synchronous and asynchronous clients
 - ✅ Methods with and without `Response` wrappers
 - ✅ Custom RequestOptions and headers
+- ✅ Error handling (invalid language codes)
 
 Areas for future enhancement:
 
-- ⬜ Error handling scenarios (invalid input, network errors, etc.)
+- ⏳ Empty audio data handling (placeholder test exists)
+- ⏳ Cancellation scenarios (placeholder test exists)
 - ⬜ Performance tests
 - ⬜ Concurrent request handling
 - ⬜ Edge cases (very long audio, multiple channels, etc.)
+
+## Recording Sanitizers
+
+The tests use the test-proxy's built-in sanitizers to automatically redact sensitive information from recordings:
+
+- API keys and authentication tokens
+- Connection strings and passwords
+- Account names and identifiers
+- Hostnames in URLs
+
+Some default sanitizers (AZSDK2003, AZSDK2030, AZSDK3430, AZSDK3493) are explicitly removed to preserve resource identifiers needed for proper request matching during playback.
+
+## Managing Test Recordings
+
+### Restore recordings from assets repo
+
+```bash
+test-proxy restore -a assets.json
+```
+
+### Push new recordings to assets repo
+
+```bash
+test-proxy push -a assets.json
+```
+
+This creates a new tag in the azure-sdk-assets repository and updates `assets.json` with the new tag reference.

sdk/cognitiveservices/azure-ai-speech-transcription/src/test/java/com/azure/ai/speech/transcription/TranscriptionAsyncClientTest.java

@@ -6,6 +6,7 @@
 import com.azure.ai.speech.transcription.models.ProfanityFilterMode;
 import com.azure.ai.speech.transcription.models.TranscriptionDiarizationOptions;
 import com.azure.ai.speech.transcription.models.TranscriptionOptions;
+import com.azure.core.exception.HttpResponseException;
 import com.azure.core.http.HttpHeaderName;
 import com.azure.core.http.rest.RequestOptions;
 import org.junit.jupiter.api.Test;
@@ -157,22 +158,18 @@ public void testTranscribeAsyncWithAllOptionsFromFileWithResponse() {
 
     @Test
     public void testTranscribeAsyncWithAudioUrl() {
-        // Test with audio URL option
         createClient(true, true, sync);
 
-        // Note: This test is commented out because it requires:
-        // 1. A valid, publicly accessible URL in live/record mode
-        // 2. Proper recording of the service response
-        // 3. The audio file at the URL must be in a supported format
-        // To enable this test:
-        // - Provide a valid audio URL
-        // - Uncomment the lines below
-        // - Run in RECORD mode to capture the interaction
-        // String methodName = new Object() {
-        // }.getClass().getEnclosingMethod().getName();
-        // TranscriptionOptions options = new TranscriptionOptions("https://example.com/sample.wav");
-        // options.setLocales(Arrays.asList("en-US"));
-        // doTranscription(methodName, sync, false, audioFile, options, null);
+        String methodName = new Object() {
+        }.getClass().getEnclosingMethod().getName();
+
+        // Using a publicly accessible sample audio file from Azure samples
+        String audioUrl
+            = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-speech-sdk/master/sampledata/audiofiles/aboutSpeechSdk.wav";
+        TranscriptionOptions options = new TranscriptionOptions(audioUrl).setLocales(Arrays.asList("en-US"));
+
+        // For URL-based transcription, we don't pass the local audio file path
+        doTranscriptionWithUrl(methodName, sync, options);
     }
 
     @Test
@@ -221,43 +218,56 @@ public void testTranscribeAsyncWithProfanityModeTags() {
     public void testTranscribeAsyncWithEmptyAudioData() {
         createClient(true, true, sync);
 
-        // Test with empty audio data - this should result in a service error
-        // Note: Depending on service behavior, this may throw HttpResponseException
-        // The exact behavior should be validated based on actual service responses
-        // Example implementation:
-        // StepVerifier.create(getAsyncClient().transcribe(emptyRequestContent))
-        //     .expectError(HttpResponseException.class)
-        //     .verify(Duration.ofSeconds(30));
+        String methodName = new Object() {
+        }.getClass().getEnclosingMethod().getName();
+
+        // Test with minimal audio data - service should handle gracefully
+        TranscriptionOptions options = new TranscriptionOptions((String) null);
+
+        doTranscription(methodName, sync, false, audioFile, options, null);
     }
 
     @Test
     public void testTranscribeAsyncWithInvalidLanguageCode() {
         createClient(true, true, sync);
 
-        // Note: This test requires actual service call to verify behavior
-        // In PLAYBACK mode, this would replay the recorded error response
-        // Example implementation with StepVerifier:
-        // TranscriptionOptions options = new TranscriptionOptions().setLocales(Arrays.asList("invalid-locale"));
-        // StepVerifier.create(getAsyncClient().transcribe(requestContentWithInvalidLocale))
-        //     .expectErrorMatches(throwable -> throwable instanceof HttpResponseException
-        //         && ((HttpResponseException) throwable).getResponse().getStatusCode() == 400)
-        //     .verify(Duration.ofSeconds(30));
+        String methodName = new Object() {
+        }.getClass().getEnclosingMethod().getName();
+
+        // Use invalid language code to trigger service error
+        TranscriptionOptions options
+            = new TranscriptionOptions((String) null).setLocales(Arrays.asList("invalid-locale-code"));
+
+        // The service should return a 400 error for invalid locale
+        // doTranscription wraps exceptions in RuntimeException, so we catch that
+        try {
+            doTranscription(methodName, sync, false, audioFile, options, null);
+            // Should not reach here - the above should throw an exception
+            throw new AssertionError("Expected RuntimeException with HttpResponseException cause but none was thrown");
+        } catch (RuntimeException e) {
+            // Expected behavior - verify the cause is HttpResponseException with 400 status
+            if (!(e.getCause() instanceof HttpResponseException)) {
+                throw new AssertionError(
+                    "Expected RuntimeException cause to be HttpResponseException but got: " + e.getCause().getClass());
+            }
+            HttpResponseException httpException = (HttpResponseException) e.getCause();
+            if (httpException.getResponse().getStatusCode() != 400) {
+                throw new AssertionError(
+                    "Expected 400 status code but got: " + httpException.getResponse().getStatusCode());
+            }
+        }
     }
 
     @Test
     public void testTranscribeAsyncCancellation() {
         createClient(true, true, sync);
 
-        // Test that async operations can be cancelled properly
-        // This verifies that the reactive streams support cancellation
-
-        // Note: Cancellation testing would typically involve subscribing and then cancelling
-        // Example pattern (commented out as it requires specific test setup):
-        // String methodName = new Object() {
-        // }.getClass().getEnclosingMethod().getName();
-        // TranscriptionOptions options = new TranscriptionOptions();
-        // Disposable subscription = getAsyncClient().transcribe(requestContent).subscribe();
-        // subscription.dispose();
-        // Verify that resources are cleaned up appropriately
+        String methodName = new Object() {
+        }.getClass().getEnclosingMethod().getName();
+
+        // Test cancellation behavior with a normal transcription request
+        TranscriptionOptions options = new TranscriptionOptions((String) null);
+
+        doTranscription(methodName, sync, false, audioFile, options, null);
     }
 }

sdk/cognitiveservices/azure-ai-speech-transcription/src/test/java/com/azure/ai/speech/transcription/TranscriptionClientTest.java

@@ -170,6 +170,22 @@ public void testTranscribeSyncWithMultipleChannels() {
         doTranscription(methodName, sync, false, audioFile, options, null);
     }
 
+    @Test
+    public void testTranscribeSyncWithAudioUrl() {
+        createClient(true, true, sync);
+
+        String methodName = new Object() {
+        }.getClass().getEnclosingMethod().getName();
+
+        // Using a publicly accessible sample audio file from Azure samples
+        String audioUrl
+            = "https://raw.githubusercontent.com/Azure-Samples/cognitive-services-speech-sdk/master/sampledata/audiofiles/aboutSpeechSdk.wav";
+        TranscriptionOptions options = new TranscriptionOptions(audioUrl).setLocales(Arrays.asList("en-US"));
+
+        // For URL-based transcription, we don't pass the local audio file path
+        doTranscriptionWithUrl(methodName, sync, options);
+    }
+
     /***********************************************************************************
      *
      *                            ERROR HANDLING TESTS