@autorest/python 6.13.14 → 6.13.15

package/autorest/codegen/__init__.py

@@ -37,6 +37,7 @@ class OptionsRetriever:
         "multiapi": False,
         "polymorphic-examples": 5,
         "generate-sample": False,
+        "generate-test": False,
         "from-typespec": False,
         "emit-cross-language-definition-file": False,
     }
@@ -332,6 +333,7 @@ class CodeGenerator(Plugin):
             "packaging_files_config",
             "default_optional_constants_to_none",
             "generate_sample",
+            "generate_test",
             "default_api_version",
             "from_typespec",
             "flavor",
@@ -436,6 +438,7 @@ class CodeGeneratorAutorest(CodeGenerator, PluginAutorest):
                 "default-optional-constants-to-none"
             ),
             "generate-sample": self._autorestapi.get_boolean_value("generate-sample"),
+            "generate-test": self._autorestapi.get_boolean_value("generate-test"),
             "default-api-version": self._autorestapi.get_value("default-api-version"),
         }
         return {k: v for k, v in options.items() if v is not None}

package/autorest/codegen/models/code_model.py

@@ -76,6 +76,7 @@ class CodeModel:  # pylint: disable=too-many-public-methods, disable=too-many-in
             t for t in self.types_map.values() if isinstance(t, CombinedType) and t.name
         ]
         self.cross_language_package_id = self.yaml_data.get("crossLanguagePackageId")
+        self.for_test: bool = False
 
     @property
     def has_form_data(self) -> bool:

package/autorest/codegen/models/enum_type.py

@@ -175,7 +175,9 @@ class EnumType(BaseType):
         :rtype: str
         """
         if self.code_model.options["models_mode"]:
-            model_name = f"_models.{self.name}"
+            module_name = "_models." if kwargs.get("need_module_name", True) else ""
+            file_name = f"{self.code_model.enums_filename}." if self.internal else ""
+            model_name = module_name + file_name + self.name
             # we don't need quoted annotation in operation files, and need it in model folder files.
             if not kwargs.get("is_operation_file", False):
                 model_name = f'"{model_name}"'

package/autorest/codegen/models/model_type.py

@@ -6,7 +6,10 @@
 from collections import OrderedDict
 from typing import Any, Dict, List, Optional, TYPE_CHECKING, cast
 import sys
-from autorest.codegen.models.utils import add_to_pylint_disable, NAME_LENGTH_LIMIT
+from autorest.codegen.models.utils import (
+    add_to_pylint_disable,
+    NAME_LENGTH_LIMIT,
+)
 from .base import BaseType
 from .constant_type import ConstantType
 from .property import Property
@@ -148,7 +151,11 @@ class ModelType(  # pylint: disable=abstract-method
         if self.discriminated_subtypes:
             # we will instead print the discriminated subtypes
             self._created_json_template_representation = False
-            return self.snake_case_name
+            return (
+                f'"{self.snake_case_name}"'
+                if self.code_model.for_test
+                else self.snake_case_name
+            )
 
         # don't add additional properties, because there's not really a concept of
         # additional properties in the template
@@ -308,13 +315,14 @@ class JSONModelType(ModelType):
 class GeneratedModelType(ModelType):  # pylint: disable=abstract-method
     def type_annotation(self, **kwargs: Any) -> str:
         is_operation_file = kwargs.pop("is_operation_file", False)
-        retval = f"_models.{self.name}"
-        if self.internal:
-            retval = f"{self.code_model.models_filename}.{retval}"
-        return retval if is_operation_file else f'"{retval}"'
+        skip_quote = kwargs.get("skip_quote", False)
+        module_name = "_models." if kwargs.get("need_module_name", True) else ""
+        file_name = f"{self.code_model.models_filename}." if self.internal else ""
+        retval = module_name + file_name + self.name
+        return retval if is_operation_file or skip_quote else f'"{retval}"'
 
     def docstring_type(self, **kwargs: Any) -> str:
-        return f"~{self.code_model.namespace}.models.{self.name}"
+        return f"~{self.code_model.namespace}.models.{self.type_annotation(need_module_name=False, skip_quote=True)}"
 
     def docstring_text(self, **kwargs: Any) -> str:
         return self.name
@@ -358,8 +366,7 @@ class MsrestModelType(GeneratedModelType):
 
     @property
     def serialization_type(self) -> str:
-        private_model_path = f"_models.{self.code_model.models_filename}."
-        return f"{private_model_path if self.internal else ''}{self.name}"
+        return self.type_annotation(skip_quote=True) if self.internal else self.name
 
     @property
     def instance_check_template(self) -> str:
@@ -378,7 +385,11 @@ class DPGModelType(GeneratedModelType):
 
     @property
     def serialization_type(self) -> str:
-        return f"{'_models.' if self.internal else ''}_models.{self.name}"
+        return (
+            self.type_annotation(skip_quote=True)
+            if self.internal
+            else self.type_annotation(need_module_name=False, skip_quote=True)
+        )
 
     @property
     def instance_check_template(self) -> str:

package/autorest/codegen/models/operation.py

@@ -217,7 +217,7 @@ class OperationBase(  # pylint: disable=too-many-public-methods,too-many-instanc
             return None
         excep_schema = default_exceptions[0].type
         if isinstance(excep_schema, ModelType):
-            return f"_models.{excep_schema.name}"
+            return excep_schema.type_annotation(skip_quote=True)
         # in this case, it's just an AnyType
         return "'object'"
 

package/autorest/codegen/models/primitive_types.py

@@ -62,7 +62,9 @@ class PrimitiveType(BaseType):  # pylint: disable=abstract-method
             comment = add_to_description(comment, description)
         if comment:
             comment = f"# {comment}"
-        return f"{client_default_value_declaration}{comment}"
+        return client_default_value_declaration + (
+            "" if self.code_model.for_test else comment
+        )
 
     @property
     def default_template_representation_declaration(self) -> str:

package/autorest/codegen/models/property.py

@@ -134,7 +134,8 @@ class Property(BaseModel):  # pylint: disable=too-many-instance-attributes
         description: Optional[str] = None,
     ) -> Any:
         if self.is_multipart_file_input:
-            return "[filetype]" if self.type.type == "list" else "filetype"
+            file_type_str = '"filetype"' if self.code_model.for_test else "filetype"
+            return f"[{file_type_str}]" if self.type.type == "list" else file_type_str
         if self.client_default_value:
             client_default_value_declaration = self.get_declaration(
                 self.client_default_value

package/autorest/codegen/serializers/__init__.py

@@ -27,6 +27,7 @@ from .metadata_serializer import MetadataSerializer
 from .request_builders_serializer import RequestBuildersSerializer
 from .patch_serializer import PatchSerializer
 from .sample_serializer import SampleSerializer
+from .test_serializer import TestSerializer, TestGeneralSerializer
 from .types_serializer import TypesSerializer
 from ..._utils import to_snake_case
 from .._utils import VALID_PACKAGE_MODE
@@ -146,6 +147,14 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
         ):
             self._serialize_and_write_sample(env, namespace_path)
 
+        if (
+            self.code_model.options["show_operations"]
+            and self.code_model.has_operations
+            and self.code_model.options["generate_test"]
+            and not self.code_model.options["azure_arm"]
+        ):
+            self._serialize_and_write_test(env, namespace_path)
+
     def serialize(self) -> None:
         env = Environment(
             loader=PackageLoader("autorest.codegen", "templates"),
@@ -631,6 +640,40 @@ class JinjaSerializer(ReaderAndWriter):  # pylint: disable=abstract-method
                             log_error = f"error happens in sample {file}: {e}"
                             _LOGGER.error(log_error)
 
+    def _serialize_and_write_test(self, env: Environment, namespace_path: Path):
+        self.code_model.for_test = True
+        out_path = self._package_root_folder(namespace_path) / Path("generated_tests")
+        general_serializer = TestGeneralSerializer(code_model=self.code_model, env=env)
+        self.write_file(
+            out_path / "conftest.py", general_serializer.serialize_conftest()
+        )
+        for is_async in (True, False):
+            async_suffix = "_async" if is_async else ""
+            general_serializer.is_async = is_async
+            self.write_file(
+                out_path / f"testpreparer{async_suffix}.py",
+                general_serializer.serialize_testpreparer(),
+            )
+
+        for client in self.code_model.clients:
+            for og in client.operation_groups:
+                test_serializer = TestSerializer(
+                    self.code_model, env, client=client, operation_group=og
+                )
+                for is_async in (True, False):
+                    try:
+                        test_serializer.is_async = is_async
+                        self.write_file(
+                            out_path
+                            / f"{to_snake_case(test_serializer.test_class_name)}.py",
+                            test_serializer.serialize_test(),
+                        )
+                    except Exception as e:  # pylint: disable=broad-except
+                        # test generation shall not block code generation, so just log error
+                        log_error = f"error happens in test generation for operation group {og.class_name}: {e}"
+                        _LOGGER.error(log_error)
+        self.code_model.for_test = False
+
 
 class JinjaSerializerAutorest(JinjaSerializer, ReaderAndWriterAutorest):
     def __init__(

package/autorest/codegen/serializers/builder_serializer.py

@@ -4,10 +4,9 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-import json
 from abc import abstractmethod
 from collections import defaultdict
-from typing import Any, Generic, List, Type, TypeVar, Dict, Union, Optional, cast
+from typing import Generic, List, Type, TypeVar, Dict, Union, Optional, cast
 
 from ..models import (
     Operation,
@@ -84,34 +83,13 @@ def _escape_str(input_str: str) -> str:
     return f'"{replace}"'
 
 
-def _improve_json_string(template_representation: str) -> Any:
-    origin = template_representation.split("\n")
-    final = []
-    for line in origin:
-        idx0 = line.find("#")
-        idx1 = line.rfind('"')
-        modified_line = ""
-        if idx0 > -1 and idx1 > -1:
-            modified_line = line[:idx0] + line[idx1:] + "  " + line[idx0:idx1] + "\n"
-        else:
-            modified_line = line + "\n"
-        modified_line = modified_line.replace('"', "").replace("\\", '"')
-        final.append(modified_line)
-    return "".join(final)
-
-
-def _json_dumps_template(template_representation: Any) -> Any:
-    # only for template use, since it wraps everything in strings
-    return _improve_json_string(json.dumps(template_representation, indent=4))
-
-
 def _get_polymorphic_subtype_template(polymorphic_subtype: ModelType) -> List[str]:
     retval: List[str] = []
     retval.append("")
     retval.append(
         f'# JSON input template for discriminator value "{polymorphic_subtype.discriminator_value}":'
     )
-    subtype_template = _json_dumps_template(
+    subtype_template = utils.json_dumps_template(
         polymorphic_subtype.get_json_template_representation(),
     )
 
@@ -229,7 +207,7 @@ def _get_json_response_template_to_status_codes(
         if not json_template:
             continue
         status_codes = [str(status_code) for status_code in response.status_codes]
-        response_json = _json_dumps_template(json_template)
+        response_json = utils.json_dumps_template(json_template)
         retval[response_json].extend(status_codes)
     return retval
 
@@ -440,7 +418,7 @@ class _BuilderBaseSerializer(Generic[BuilderType]):  # pylint: disable=abstract-
         template.append(
             "# JSON input template you can fill out and use as your body input."
         )
-        json_template = _json_dumps_template(
+        json_template = utils.json_dumps_template(
             json_type.get_json_template_representation(),
         )
         template.extend(

package/autorest/codegen/serializers/test_serializer.py

@@ -0,0 +1,283 @@
+# pylint: disable=too-many-lines
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from typing import Dict, Any, List, Optional
+from jinja2 import Environment
+
+from .import_serializer import FileImportSerializer
+from .base_serializer import BaseSerializer
+from ..models import (
+    CodeModel,
+    ImportType,
+    OperationGroup,
+    Client,
+    OperationType,
+    ModelType,
+    BaseType,
+    CombinedType,
+)
+from .utils import get_namespace_from_package_name, json_dumps_template
+
+
+class TestName:
+    def __init__(self, client_name: str, *, is_async: bool = False) -> None:
+        self.client_name = client_name
+        self.is_async = is_async
+
+    @property
+    def async_suffix_capt(self) -> str:
+        return "Async" if self.is_async else ""
+
+    @property
+    def create_client_name(self) -> str:
+        return "create_async_client" if self.is_async else "create_client"
+
+    @property
+    def prefix(self) -> str:
+        return self.client_name.replace("Client", "")
+
+    @property
+    def preparer_name(self) -> str:
+        return self.prefix + "Preparer"
+
+    @property
+    def base_test_class_name(self) -> str:
+        return f"{self.client_name}TestBase{self.async_suffix_capt}"
+
+
+class TestCase:
+    def __init__(
+        self,
+        operation_groups: List[OperationGroup],
+        params: Dict[str, Any],
+        operation: OperationType,
+        *,
+        is_async: bool = False,
+    ) -> None:
+        self.operation_groups = operation_groups
+        self.params = params
+        self.operation = operation
+        self.is_async = is_async
+
+    @property
+    def operation_group_prefix(self) -> str:
+        if self.operation_groups[-1].is_mixin:
+            return ""
+        return "." + ".".join([og.property_name for og in self.operation_groups])
+
+    @property
+    def response(self) -> str:
+        if self.is_async:
+            if self.operation.operation_type == "lropaging":
+                return "response = await (await "
+            return "response = await "
+        return "response = "
+
+    @property
+    def lro_comment(self) -> str:
+        return " # poll until service return final result"
+
+    @property
+    def operation_suffix(self) -> str:
+        if self.operation.operation_type == "lropaging":
+            extra = ")" if self.is_async else ""
+            return f"{extra}.result(){self.lro_comment}"
+        return ""
+
+    @property
+    def extra_operation(self) -> str:
+        if self.is_async:
+            if self.operation.operation_type == "lro":
+                return f"result = await response.result(){self.lro_comment}"
+            if self.operation.operation_type == ("lropaging", "paging"):
+                return "result = [r async for r in response]"
+        else:
+            if self.operation.operation_type == "lro":
+                return f"result = response.result(){self.lro_comment}"
+            if self.operation.operation_type in ("lropaging", "paging"):
+                return "result = [r for r in response]"
+        return ""
+
+
+class Test(TestName):
+    def __init__(
+        self,
+        client_name: str,
+        operation_group: OperationGroup,
+        testcases: List[TestCase],
+        test_class_name: str,
+        *,
+        is_async: bool = False,
+    ) -> None:
+        super().__init__(client_name, is_async=is_async)
+        self.operation_group = operation_group
+        self.testcases = testcases
+        self.test_class_name = test_class_name
+
+
+class TestGeneralSerializer(BaseSerializer):
+    def __init__(
+        self, code_model: CodeModel, env: Environment, *, is_async: bool = False
+    ) -> None:
+        super().__init__(code_model, env)
+        self.is_async = is_async
+
+    @property
+    def aio_str(self) -> str:
+        return ".aio" if self.is_async else ""
+
+    @property
+    def test_names(self) -> List[TestName]:
+        return [
+            TestName(c.name, is_async=self.is_async) for c in self.code_model.clients
+        ]
+
+    @property
+    def import_clients(self) -> FileImportSerializer:
+        imports = self.init_file_import()
+        namespace = get_namespace_from_package_name(
+            self.code_model.options["package_name"]
+        )
+
+        imports.add_submodule_import(
+            "devtools_testutils", "AzureRecordedTestCase", ImportType.STDLIB
+        )
+        if not self.is_async:
+            imports.add_import("functools", ImportType.STDLIB)
+            imports.add_submodule_import(
+                "devtools_testutils", "PowerShellPreparer", ImportType.STDLIB
+            )
+        for client in self.code_model.clients:
+            imports.add_submodule_import(
+                namespace + self.aio_str, client.name, ImportType.STDLIB
+            )
+        return FileImportSerializer(imports, self.is_async)
+
+    def serialize_conftest(self) -> str:
+        return self.env.get_template("conftest.py.jinja2").render(
+            test_names=self.test_names,
+            code_model=self.code_model,
+        )
+
+    def serialize_testpreparer(self) -> str:
+        return self.env.get_template("testpreparer.py.jinja2").render(
+            test_names=self.test_names,
+            imports=self.import_clients,
+            code_model=self.code_model,
+        )
+
+
+class TestSerializer(TestGeneralSerializer):
+    def __init__(
+        self,
+        code_model: CodeModel,
+        env: Environment,
+        *,
+        client: Client,
+        operation_group: OperationGroup,
+        is_async: bool = False,
+    ) -> None:
+        super().__init__(code_model, env, is_async=is_async)
+        self.client = client
+        self.operation_group = operation_group
+
+    @property
+    def import_test(self) -> FileImportSerializer:
+        imports = self.init_file_import()
+        test_name = TestName(self.client.name, is_async=self.is_async)
+        async_suffix = "_async" if self.is_async else ""
+        imports.add_submodule_import(
+            "testpreparer" + async_suffix,
+            test_name.base_test_class_name,
+            ImportType.LOCAL,
+        )
+        imports.add_submodule_import(
+            "testpreparer", test_name.preparer_name, ImportType.LOCAL
+        )
+        imports.add_submodule_import(
+            "devtools_testutils" + self.aio_str,
+            "recorded_by_proxy" + async_suffix,
+            ImportType.LOCAL,
+        )
+        return FileImportSerializer(imports, self.is_async)
+
+    @property
+    def breadth_search_operation_group(self) -> List[List[OperationGroup]]:
+        result = []
+        queue = [[self.operation_group]]
+        while queue:
+            current = queue.pop(0)
+            if current[-1].operations:
+                result.append(current)
+            if current[-1].operation_groups:
+                queue.extend([current + [og] for og in current[-1].operation_groups])
+        return result
+
+    def get_sub_type(self, param_type: ModelType) -> ModelType:
+        if param_type.discriminated_subtypes:
+            for item in param_type.discriminated_subtypes.values():
+                return self.get_sub_type(item)
+        return param_type
+
+    def get_model_type(self, param_type: BaseType) -> Optional[ModelType]:
+        if isinstance(param_type, ModelType):
+            return param_type
+        if isinstance(param_type, CombinedType):
+            return param_type.target_model_subtype((ModelType,))
+        return None
+
+    def get_operation_params(self, operation: OperationType) -> Dict[str, Any]:
+        operation_params = {}
+        required_params = [p for p in operation.parameters.method if not p.optional]
+        for param in required_params:
+            model_type = self.get_model_type(param.type)
+            param_type = self.get_sub_type(model_type) if model_type else param.type
+            operation_params[param.client_name] = json_dumps_template(
+                param_type.get_json_template_representation()
+            )
+        return operation_params
+
+    def get_test(self) -> Test:
+        testcases = []
+        for operation_groups in self.breadth_search_operation_group:
+            for operation in operation_groups[-1].operations:
+                if operation.internal or operation.is_lro_initial_operation:
+                    continue
+                operation_params = self.get_operation_params(operation)
+                testcase = TestCase(
+                    operation_groups=operation_groups,
+                    params=operation_params,
+                    operation=operation,
+                    is_async=self.is_async,
+                )
+                testcases.append(testcase)
+        if not testcases:
+            raise Exception(  # pylint: disable=broad-exception-raised
+                "no public operation to test"
+            )
+
+        return Test(
+            client_name=self.client.name,
+            operation_group=self.operation_group,
+            testcases=testcases,
+            test_class_name=self.test_class_name,
+            is_async=self.is_async,
+        )
+
+    @property
+    def test_class_name(self) -> str:
+        test_name = TestName(self.client.name, is_async=self.is_async)
+        class_name = (
+            "" if self.operation_group.is_mixin else self.operation_group.class_name
+        )
+        return f"Test{test_name.prefix}{class_name}{test_name.async_suffix_capt}"
+
+    def serialize_test(self) -> str:
+        return self.env.get_template("test.py.jinja2").render(
+            imports=self.import_test,
+            code_model=self.code_model,
+            test=self.get_test(),
+        )

package/autorest/codegen/serializers/utils.py

@@ -3,7 +3,8 @@
 # Licensed under the MIT License. See License.txt in the project root for
 # license information.
 # --------------------------------------------------------------------------
-from typing import Optional, List
+import json
+from typing import Optional, List, Any
 from pathlib import Path
 
 from ..models import Client, OperationGroup
@@ -44,3 +45,24 @@ def get_all_operation_groups_recursively(clients: List[Client]) -> List[Operatio
         if operation_groups[-1].operation_groups:
             queue.extend(operation_groups[-1].operation_groups)
     return operation_groups
+
+
+def _improve_json_string(template_representation: str) -> Any:
+    origin = template_representation.split("\n")
+    final = []
+    for line in origin:
+        idx0 = line.find("#")
+        idx1 = line.rfind('"')
+        modified_line = ""
+        if idx0 > -1 and idx1 > -1:
+            modified_line = line[:idx0] + line[idx1:] + "  " + line[idx0:idx1] + "\n"
+        else:
+            modified_line = line + "\n"
+        modified_line = modified_line.replace('"', "").replace("\\", '"')
+        final.append(modified_line)
+    return "".join(final)
+
+
+def json_dumps_template(template_representation: Any) -> Any:
+    # only for template use, since it wraps everything in strings
+    return _improve_json_string(json.dumps(template_representation, indent=4))

package/autorest/codegen/templates/conftest.py.jinja2

@@ -0,0 +1,28 @@
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+import os
+import pytest
+from dotenv import load_dotenv
+from devtools_testutils import test_proxy, add_general_regex_sanitizer, add_body_key_sanitizer, add_header_regex_sanitizer
+
+load_dotenv()
+
+# aovid record sensitive identity information in recordings
+@pytest.fixture(scope="session", autouse=True)
+def add_sanitizers(test_proxy):
+    {% for test_name in test_names %}
+    {% set prefix_upper = test_name.prefix|upper %}
+    {% set prefix_lower = test_name.prefix|lower %}
+    {{ prefix_lower }}_subscription_id = os.environ.get("{{ prefix_upper }}_SUBSCRIPTION_ID", "00000000-0000-0000-0000-000000000000")
+    {{ prefix_lower }}_tenant_id = os.environ.get("{{ prefix_upper }}_TENANT_ID", "00000000-0000-0000-0000-000000000000")
+    {{ prefix_lower }}_client_id = os.environ.get("{{ prefix_upper }}_CLIENT_ID", "00000000-0000-0000-0000-000000000000")
+    {{ prefix_lower }}_client_secret = os.environ.get("{{ prefix_upper }}_CLIENT_SECRET", "00000000-0000-0000-0000-000000000000")
+    add_general_regex_sanitizer(regex={{ prefix_lower }}_subscription_id, value="00000000-0000-0000-0000-000000000000")
+    add_general_regex_sanitizer(regex={{ prefix_lower }}_tenant_id, value="00000000-0000-0000-0000-000000000000")
+    add_general_regex_sanitizer(regex={{ prefix_lower }}_client_id, value="00000000-0000-0000-0000-000000000000")
+    add_general_regex_sanitizer(regex={{ prefix_lower }}_client_secret, value="00000000-0000-0000-0000-000000000000")
+
+    {% endfor %}
+    add_header_regex_sanitizer(key="Set-Cookie", value="[set-cookie;]")
+    add_header_regex_sanitizer(key="Cookie", value="cookie;")
+    add_body_key_sanitizer(json_path="$..access_token", value="access_token")

package/autorest/codegen/templates/model_base.py.jinja2

@@ -6,6 +6,7 @@
 # --------------------------------------------------------------------------
 # pylint: disable=protected-access, arguments-differ, signature-differs, broad-except
 
+import copy
 import calendar
 import decimal
 import functools
@@ -655,6 +656,12 @@ def _deserialize_sequence(
         return obj
     return type(obj)(_deserialize(deserializer, entry, module) for entry in obj)
 
+def _sorted_annotations(types: typing.List[typing.Any]) -> typing.List[typing.Any]:
+    return sorted(
+        types,
+        key=lambda x: hasattr(x, "__name__") and x.__name__.lower() in ("str", "float", "int", "bool"),
+    )
+
 def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915, R0912
     annotation: typing.Any,
     module: typing.Optional[str],
@@ -696,21 +703,25 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=R0911, R0915,
     # is it optional?
     try:
         if any(a for a in annotation.__args__ if a == type(None)):  # pyright: ignore
-            if_obj_deserializer = _get_deserialize_callable_from_annotation(
-                next(a for a in annotation.__args__ if a != type(None)), module, rf  # pyright: ignore
-            )
-
-            return functools.partial(_deserialize_with_optional, if_obj_deserializer)
+            if len(annotation.__args__) <= 2: # pyright: ignore
+                if_obj_deserializer = _get_deserialize_callable_from_annotation(
+                    next(a for a in annotation.__args__ if a != type(None)), module, rf # pyright: ignore
+                )
+
+                return functools.partial(_deserialize_with_optional, if_obj_deserializer)
+            # the type is Optional[Union[...]], we need to remove the None type from the Union
+            annotation_copy = copy.copy(annotation)
+            annotation_copy.__args__ = [a for a in annotation_copy.__args__ if a != type(None)] # pyright: ignore
+            return _get_deserialize_callable_from_annotation(annotation_copy, module, rf)
     except AttributeError:
         pass
 
+    # is it union?
     if getattr(annotation, "__origin__", None) is typing.Union:
         # initial ordering is we make `string` the last deserialization option, because it is often them most generic
         deserializers = [
             _get_deserialize_callable_from_annotation(arg, module, rf)
-            for arg in sorted(
-            annotation.__args__, key=lambda x: hasattr(x, "__name__") and x.__name__ == "str"  # pyright: ignore
-        )
+            for arg in _sorted_annotations(annotation.__args__)  # pyright: ignore
         ]
 
         return functools.partial(_deserialize_with_union, deserializers)

package/autorest/codegen/templates/test.py.jinja2

@@ -0,0 +1,26 @@
+{% set prefix_lower = test.prefix|lower %}
+{% set async = "async " if test.is_async else "" %}
+{% set async_suffix = "_async" if test.is_async else "" %}
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+import pytest
+{{ imports }}
+
+
+@pytest.mark.skip("you may need to update the auto-generated test case before run it")
+class {{ test.test_class_name }}({{ test.base_test_class_name }}):
+{% for testcase in test.testcases %}
+    @{{ test.preparer_name }}()
+    @recorded_by_proxy{{ async_suffix }}
+    {{ async }}def test_{{ testcase.operation.name }}(self, {{ prefix_lower }}_endpoint):
+        client = self.{{ test.create_client_name }}(endpoint={{ prefix_lower }}_endpoint)
+        {{testcase.response }}client{{ testcase.operation_group_prefix }}.{{ testcase.operation.name }}(
+            {% for key, value in testcase.params.items() %}
+            {{ key }}={{ value|indent(12) }},
+            {% endfor %}
+        ){{ testcase.operation_suffix }}
+        {{ testcase.extra_operation }}
+        # please add some check logic here by yourself
+        # ...
+
+{% endfor %}

package/autorest/codegen/templates/testpreparer.py.jinja2

@@ -0,0 +1,26 @@
+# coding=utf-8
+{{ code_model.options['license_header'] }}
+{{ imports }}
+
+{% for test_name in test_names %}
+{% set extra_async = ", is_async=True" if test_name.is_async else ""%}
+{% set prefix_lower = test_name.prefix|lower %}
+class {{ test_name.base_test_class_name }}(AzureRecordedTestCase):
+
+    def {{ test_name.create_client_name }}(self, endpoint):
+        credential = self.get_credential({{ test_name.client_name }}{{ extra_async }})
+        return self.create_client_from_credential(
+            {{ test_name.client_name }},
+            credential=credential,
+            endpoint=endpoint,
+        )
+
+{% if not test_name.is_async %}
+{{ test_name.preparer_name }} = functools.partial(
+    PowerShellPreparer,
+    "{{ prefix_lower }}",
+    {{ prefix_lower }}_endpoint="https://fake_{{ prefix_lower }}_endpoint.com"
+)
+{% endif %}
+
+{% endfor %}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autorest/python",
-  "version": "6.13.14",
+  "version": "6.13.15",
   "description": "The Python extension for generators in AutoRest.",
   "main": "index.js",
   "repository": {