# coding=utf-8 # -------------------------------------------------------------------------- # Copyright (c) Microsoft Corporation. All rights reserved. # Licensed under the MIT License. # -------------------------------------------------------------------------- import pytest from enum import Enum from typing import cast from azure.ai.voicelive._utils.serialization import Serializer, SerializationError from azure.ai.voicelive.models import ( AzureVoiceType, MessageRole, OpenAIVoiceName, InputAudioFormat, OutputAudioFormat, ItemParamStatus, ResponseStatus, Modality, InputTextContentPart, OutputTextContentPart, UserMessageItem, AssistantMessageItem, AzureStandardVoice, OpenAIVoice, ) class EnumForTest(str, Enum): """Enum for serialization testing.""" VALUE_A = "value_a" VALUE_B = "value_b" class TestSerializerBasicTypes: """Test serializer with basic types.""" def setUp(self): """Set up serializer for testing.""" self.serializer = Serializer() def test_serialize_string(self): """Test string serialization.""" serializer = Serializer() result = serializer.serialize_data("test_string", "str") assert result == "test_string" def test_serialize_int(self): """Test integer serialization.""" serializer = Serializer() result = serializer.serialize_data(42, "int") assert result == 42 def test_serialize_float(self): """Test float serialization.""" serializer = Serializer() result = serializer.serialize_data(3.14, "float") assert result == 3.14 def test_serialize_bool(self): """Test boolean serialization.""" serializer = Serializer() result = serializer.serialize_data(True, "bool") assert result is True result = serializer.serialize_data(False, "bool") assert result is False def test_serialize_none(self): """Test None serialization.""" serializer = Serializer() with pytest.raises(ValueError): serializer.serialize_data(None, "str") class TestSerializerEnums: """Test serializer with enum types.""" def test_serialize_azure_voice_type(self): """Test AzureVoiceType enum serialization.""" serializer = Serializer() result = serializer.serialize_data(AzureVoiceType.AZURE_CUSTOM, "str") assert result == "azure-custom" def test_serialize_message_role(self): """Test MessageRole enum serialization.""" serializer = Serializer() result = serializer.serialize_data(MessageRole.ASSISTANT, "str") assert result == "assistant" def test_serialize_oai_voice(self): """Test OpenAIVoiceName enum serialization.""" serializer = Serializer() result = serializer.serialize_data(OpenAIVoiceName.ALLOY, "str") assert result == "alloy" def test_serialize_input_audio_format(self): """Test InputAudioFormat enum serialization.""" serializer = Serializer() result = serializer.serialize_data(InputAudioFormat.PCM16, "str") assert result == "pcm16" def test_serialize_output_audio_format(self): """Test OutputAudioFormat enum serialization.""" serializer = Serializer() result = serializer.serialize_data(OutputAudioFormat.G711_ULAW, "str") assert result == "g711_ulaw" def test_serialize_response_status(self): """Test ResponseStatus enum serialization.""" serializer = Serializer() result = serializer.serialize_data(ResponseStatus.COMPLETED, "str") assert result == "completed" def test_serialize_custom_test_enum(self): """Test custom test enum serialization.""" serializer = Serializer() result = serializer.serialize_data(EnumForTest.VALUE_A, "str") assert result == "value_a" class TestSerializerEnumTypeCasting: """Test the specific enum type casting fix from the recent changes.""" def test_enum_type_casting_fix(self): """Test that enum type casting works correctly. This tests the specific fix where data.__class__ is cast to type in the serialization utilities. """ serializer = Serializer() # Test with various enum types to ensure the cast(type, data.__class__) fix works enums_to_test = [ (AzureVoiceType.AZURE_CUSTOM, "azure-custom"), (MessageRole.USER, "user"), (OpenAIVoiceName.SHIMMER, "shimmer"), (InputAudioFormat.G711_ALAW, "g711_alaw"), (ItemParamStatus.COMPLETED, "completed"), (Modality.AUDIO, "audio"), ] for enum_value, expected_result in enums_to_test: result = serializer.serialize_data(enum_value, "str") assert result == expected_result, f"Failed for {enum_value}: expected {expected_result}, got {result}" def test_enum_class_attribute_casting(self): """Test that the enum class casting works with __class__ attribute.""" serializer = Serializer() # Create enum instances and test that their __class__ can be cast to type voice_type = AzureVoiceType.AZURE_STANDARD role = MessageRole.ASSISTANT # These should not raise TypeError due to the cast(type, data.__class__) fix voice_result = serializer.serialize_data(voice_type, "str") role_result = serializer.serialize_data(role, "str") assert voice_result == "azure-standard" assert role_result == "assistant" def test_enum_inheritance_check(self): """Test that enum inheritance checking works correctly.""" serializer = Serializer() # Test that issubclass works with the casted type voice_type = AzureVoiceType.AZURE_PERSONAL # This should work without TypeError result = serializer.serialize_data(voice_type, "str") assert result == "azure-personal" # Verify the enum is still recognized as an Enum subclass casted_type = cast(type, voice_type.__class__) assert issubclass(casted_type, Enum) class TestSerializerCollections: """Test serializer with collections containing enums.""" def test_serialize_list_of_enums(self): """Test serializing a list of enums.""" serializer = Serializer() enum_list = [AzureVoiceType.AZURE_CUSTOM, AzureVoiceType.AZURE_STANDARD] result = serializer.serialize_data(enum_list, "[str]") assert result == ["azure-custom", "azure-standard"] def test_serialize_list_of_modalities(self): """Test serializing a list of modality enums.""" serializer = Serializer() modalities = [Modality.TEXT, Modality.AUDIO, Modality.ANIMATION] result = serializer.serialize_data(modalities, "[str]") assert result == ["text", "audio", "animation"] def test_serialize_mixed_list(self): """Test serializing a list with mixed types.""" serializer = Serializer() mixed_list = ["string", 42, True, MessageRole.SYSTEM] # Note: This might need adjustment based on actual serializer behavior # The test verifies that enums in mixed collections are handled correctly try: result = serializer.serialize_data(mixed_list, "[object]") # At minimum, ensure no exceptions are raised assert isinstance(result, list) except (SerializationError, NotImplementedError): # Some serializers may not support mixed types pytest.skip("Serializer doesn't support mixed type collections") class TestSerializerModels: """Test serializer with model objects.""" def test_serialize_content_part(self): """Test serializing content parts.""" serializer = Serializer() content = InputTextContentPart(text="Hello, world!") # Test that model objects can be serialized # The exact behavior depends on the model's serialization implementation try: result = serializer.serialize_data(content, "object") assert isinstance(result, dict) or hasattr(content, "as_dict") except (SerializationError, AttributeError): # If direct serialization isn't supported, at least verify the object exists assert content.text == "Hello, world!" assert content.type == "input_text" def test_serialize_message_item(self): """Test serializing message items.""" serializer = Serializer() content = [InputTextContentPart(text="Test message")] message = UserMessageItem(content=content) # Verify the message has the correct structure assert message.role == MessageRole.USER assert len(message.content) == 1 assert message.content[0].text == "Test message" def test_serialize_voice_config(self): """Test serializing voice configurations.""" serializer = Serializer() voice = AzureStandardVoice(name="test-voice", temperature=0.7) # Verify voice configuration structure assert voice.type == AzureVoiceType.AZURE_STANDARD assert voice.name == "test-voice" assert voice.temperature == 0.7 class TestSerializerErrorHandling: """Test serializer error handling.""" def test_serialization_error_handling(self): """Test that serialization errors are properly handled.""" serializer = Serializer() # Test with an object that can't be serialized class UnserializableObject: def __init__(self): self._private = "private" obj = UnserializableObject() # This should either serialize or raise a SerializationError try: result = serializer.serialize_data(obj, "object") # If serialization succeeds, verify it's reasonable assert isinstance(result, (dict, str)) or result is None except (SerializationError, TypeError): # Expected for truly unserializable objects pass def test_invalid_data_type_specification(self): """Test handling of invalid data type specifications.""" serializer = Serializer() try: # Try with an invalid type specification result = serializer.serialize_data("test", "invalid_type") # If it doesn't raise an error, it should return something reasonable assert result is not None except (SerializationError, ValueError, TypeError): # Expected for invalid type specifications pass class TestSerializerIntegration: """Integration tests for serializer functionality.""" def test_complex_enum_scenarios(self): """Test complex scenarios with multiple enum types.""" serializer = Serializer() # Create a complex scenario with nested enums voice_types = [AzureVoiceType.AZURE_CUSTOM, AzureVoiceType.AZURE_STANDARD, AzureVoiceType.AZURE_PERSONAL] roles = [MessageRole.SYSTEM, MessageRole.USER, MessageRole.ASSISTANT] # Test serializing multiple enum collections voice_result = serializer.serialize_data(voice_types, "[str]") roles_result = serializer.serialize_data(roles, "[str]") assert voice_result == ["azure-custom", "azure-standard", "azure-personal"] assert roles_result == ["system", "user", "assistant"] def test_enum_with_model_objects(self): """Test enums used within model objects.""" content = [OutputTextContentPart(text="Assistant response")] message = AssistantMessageItem(content=content) # Verify that enums within models work correctly assert message.role == MessageRole.ASSISTANT assert message.content[0].type == "text" # Test that the discriminator enum values are properly set openai_voice = OpenAIVoice(name=OpenAIVoiceName.CORAL) assert openai_voice.type == "openai" assert openai_voice.name == OpenAIVoiceName.CORAL def test_serializer_with_real_world_data(self): """Test serializer with realistic data structures.""" serializer = Serializer() # Create realistic data that might be serialized in the SDK modalities = [Modality.TEXT, Modality.AUDIO] audio_formats = [InputAudioFormat.PCM16, InputAudioFormat.G711_ULAW] modalities_result = serializer.serialize_data(modalities, "[str]") formats_result = serializer.serialize_data(audio_formats, "[str]") assert modalities_result == ["text", "audio"] assert formats_result == ["pcm16", "g711_ulaw"]