@typespec/http-client-python 0.23.0 → 0.24.0

package/generator/pygen/codegen/models/operation_group.py

@@ -93,7 +93,9 @@ class OperationGroup(BaseModel):
     @property
     def need_validation(self) -> bool:
         """Whether any of its operations need validation"""
-        return any(o for o in self.operations if o.need_validation)
+        return any(o for o in self.operations if o.need_validation) or any(
+            og for og in self.operation_groups if og.need_validation
+        )
 
     def imports(self, async_mode: bool, **kwargs: Any) -> FileImport:
         file_import = FileImport(self.code_model)

package/generator/pygen/codegen/models/request_builder.py

@@ -16,11 +16,12 @@ from typing import (
 from abc import abstractmethod
 
 from .base_builder import BaseBuilder
-from .utils import add_to_pylint_disable
+from .utils import add_to_pylint_disable, LOCALS_LENGTH_LIMIT, REQUEST_BUILDER_BODY_VARIABLES_LENGTH
 from .parameter_list import (
     RequestBuilderParameterList,
     OverloadedRequestBuilderParameterList,
 )
+from .parameter import ParameterLocation
 from .imports import FileImport, ImportType, TypingSection, MsrestImportType
 from ...utils import NAME_LENGTH_LIMIT
 
@@ -67,9 +68,25 @@ class RequestBuilderBase(BaseBuilder[ParameterListType, Sequence["RequestBuilder
         return self.yaml_data.get("discriminator") in ("lro", "lropaging")
 
     def pylint_disable(self, async_mode: bool) -> str:
+        retval = ""
         if len(self.name) > NAME_LENGTH_LIMIT:
-            return add_to_pylint_disable("", "name-too-long")
-        return ""
+            retval = add_to_pylint_disable(retval, "name-too-long")
+        method_params = self.parameters.method
+        if len(method_params) > LOCALS_LENGTH_LIMIT - REQUEST_BUILDER_BODY_VARIABLES_LENGTH:
+            retval = add_to_pylint_disable(retval, "too-many-locals")
+        if (
+            len(
+                [
+                    p
+                    for p in method_params
+                    if p.optional and p.location in [ParameterLocation.HEADER, ParameterLocation.QUERY]
+                ]
+            )
+            > LOCALS_LENGTH_LIMIT
+        ):
+            retval = add_to_pylint_disable(retval, "too-many-statements")
+            retval = add_to_pylint_disable(retval, "too-many-branches")
+        return retval
 
     def response_type_annotation(self, **kwargs) -> str:
         return "HttpRequest"

package/generator/pygen/codegen/models/response.py

@@ -233,7 +233,7 @@ class LROResponse(Response):
 
     def get_no_polling_method(self, async_mode: bool) -> str:
         """Get the default no polling method"""
-        return self.get_no_polling_method_path(async_mode).split(".")[-1]
+        return self.get_no_polling_method_path(async_mode).rsplit(".", maxsplit=1)[-1]
 
     @staticmethod
     def get_base_polling_method_path(async_mode: bool) -> str:
@@ -242,7 +242,7 @@ class LROResponse(Response):
 
     def get_base_polling_method(self, async_mode: bool) -> str:
         """Get the base polling method."""
-        return self.get_base_polling_method_path(async_mode).split(".")[-1]
+        return self.get_base_polling_method_path(async_mode).rsplit(".", maxsplit=1)[-1]
 
     def type_annotation(self, **kwargs: Any) -> str:
         return f"{self.get_poller(kwargs.get('async_mode', False))}[{super().type_annotation(**kwargs)}]"

package/generator/pygen/codegen/models/utils.py

@@ -30,3 +30,10 @@ class NamespaceType(str, Enum):
     OPERATION = "operation"
     CLIENT = "client"
     TYPES_FILE = "types_file"
+
+
+LOCALS_LENGTH_LIMIT = 25
+
+REQUEST_BUILDER_BODY_VARIABLES_LENGTH = 6  # how many body variables are present in a request builder
+
+OPERATION_BODY_VARIABLES_LENGTH = 14  # how many body variables are present in an operation

package/generator/pygen/codegen/serializers/builder_serializer.py

@@ -403,7 +403,12 @@ class RequestBuilderSerializer(_BuilderBaseSerializer[RequestBuilderType]):
         builder: RequestBuilderType,
     ) -> list[str]:
         def _get_value(param):
-            declaration = param.get_declaration() if param.constant else None
+            if param.constant:
+                declaration = param.get_declaration()
+            elif param.client_default_value_declaration is not None:
+                declaration = param.client_default_value_declaration
+            else:
+                declaration = None
             if param.location in [ParameterLocation.HEADER, ParameterLocation.QUERY]:
                 kwarg_dict = "headers" if param.location == ParameterLocation.HEADER else "params"
                 return f"_{kwarg_dict}.pop('{param.wire_name}', {declaration})"
@@ -776,8 +781,14 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
         client_names = [
             overload.request_builder.parameters.body_parameter.client_name for overload in builder.overloads
         ]
-        for v in sorted(set(client_names), key=client_names.index):
-            retval.append(f"_{v} = None")
+        all_dpg_model_overloads = False
+        if self.code_model.options["models-mode"] == "dpg" and builder.overloads:
+            all_dpg_model_overloads = all(
+                isinstance(o.parameters.body_parameter.type, DPGModelType) for o in builder.overloads
+            )
+        if not all_dpg_model_overloads:
+            for v in sorted(set(client_names), key=client_names.index):
+                retval.append(f"_{v} = None")
         try:
             # if there is a binary overload, we do a binary check first.
             binary_overload = cast(
@@ -803,17 +814,20 @@ class _OperationSerializer(_BuilderBaseSerializer[OperationType]):
                     f'"{other_overload.parameters.body_parameter.default_content_type}"{check_body_suffix}'
                 )
         except StopIteration:
-            for idx, overload in enumerate(builder.overloads):
-                if_statement = "if" if idx == 0 else "elif"
-                body_param = overload.parameters.body_parameter
-                retval.append(
-                    f"{if_statement} {body_param.type.instance_check_template.format(body_param.client_name)}:"
-                )
-                if body_param.default_content_type and not same_content_type:
+            if all_dpg_model_overloads:
+                retval.extend(f"{l}" for l in self._create_body_parameter(cast(OperationType, builder.overloads[0])))
+            else:
+                for idx, overload in enumerate(builder.overloads):
+                    if_statement = "if" if idx == 0 else "elif"
+                    body_param = overload.parameters.body_parameter
                     retval.append(
-                        f'    content_type = content_type or "{body_param.default_content_type}"{check_body_suffix}'
+                        f"{if_statement} {body_param.type.instance_check_template.format(body_param.client_name)}:"
                     )
-                retval.extend(f"    {l}" for l in self._create_body_parameter(cast(OperationType, overload)))
+                    if body_param.default_content_type and not same_content_type:
+                        retval.append(
+                            f'    content_type = content_type or "{body_param.default_content_type}"{check_body_suffix}'
+                        )
+                    retval.extend(f"    {l}" for l in self._create_body_parameter(cast(OperationType, overload)))
         return retval
 
     def _create_request_builder_call(

package/generator/pygen/codegen/serializers/client_serializer.py

@@ -182,11 +182,10 @@ class ClientSerializer:
             retval.append("self._serialize.client_side_validation = False")
         operation_groups = [og for og in self.client.operation_groups if not og.is_mixin]
         for og in operation_groups:
-            api_version = ""
             retval.extend(
                 [
                     f"self.{og.property_name} = {og.class_name}(",
-                    f"    self._client, self._config, self._serialize, self._deserialize{api_version}",
+                    "    self._client, self._config, self._serialize, self._deserialize",
                     ")",
                 ]
             )

package/generator/pygen/codegen/serializers/general_serializer.py

@@ -23,7 +23,7 @@ VERSION_MAP = {
     "msrest": "0.7.1",
     "isodate": "0.6.1",
     "azure-mgmt-core": "1.6.0",
-    "azure-core": "1.36.0",
+    "azure-core": "1.37.0",
     "typing-extensions": "4.6.0",
     "corehttp": "1.0.0b6",
 }

package/generator/pygen/codegen/serializers/model_serializer.py

@@ -285,6 +285,9 @@ class DpgModelSerializer(_ModelSerializer):
                 file_import.add_submodule_import("typing", "overload", ImportType.STDLIB)
                 file_import.add_submodule_import("typing", "Mapping", ImportType.STDLIB)
                 file_import.add_submodule_import("typing", "Any", ImportType.STDLIB)
+        # if there is a property named `list` we have to make sure there's no conflict with the built-in `list`
+        if self.code_model.has_property_named_list:
+            file_import.define_mypy_type("List", "list")
         return file_import
 
     def declare_model(self, model: ModelType) -> str:

package/generator/pygen/codegen/templates/enum.py.jinja2

@@ -1,5 +1,7 @@
 
-class {{ enum.name }}({{ enum.value_type.type_annotation(is_operation_file=False) }}, Enum, metaclass=CaseInsensitiveEnumMeta):
+class {{ enum.name }}({{enum.pylint_disable()}}
+  {{ enum.value_type.type_annotation(is_operation_file=False) }}, Enum, metaclass=CaseInsensitiveEnumMeta
+):
     {% if enum.yaml_data.get("description") %}
     """{{ op_tools.wrap_string(enum.yaml_data["description"], "\n    ") }}
     """

package/generator/pygen/codegen/templates/model_base.py.jinja2

@@ -36,6 +36,7 @@ __all__ = ["SdkJSONEncoder", "Model", "rest_field", "rest_discriminator"]
 
 TZ_UTC = timezone.utc
 _T = typing.TypeVar("_T")
+_NONE_TYPE = type(None)
 
 {% if code_model.has_external_type %}
 TYPE_HANDLER_REGISTRY = TypeHandlerRegistry()
@@ -223,7 +224,7 @@ def _deserialize_datetime(attr: typing.Union[str, datetime]) -> datetime:
     test_utc = date_obj.utctimetuple()
     if test_utc.tm_year > 9999 or test_utc.tm_year < 1:
         raise OverflowError("Hit max or min date")
-    return date_obj
+    return date_obj  # type: ignore[no-any-return]
 
 
 def _deserialize_datetime_rfc7231(attr: typing.Union[str, datetime]) -> datetime:
@@ -277,7 +278,7 @@ def _deserialize_time(attr: typing.Union[str, time]) -> time:
     """
     if isinstance(attr, time):
         return attr
-    return isodate.parse_time(attr)
+    return isodate.parse_time(attr)  # type: ignore[no-any-return]
 
 
 def _deserialize_bytes(attr):
@@ -382,9 +383,39 @@ class _MyMutableMapping(MutableMapping[str, typing.Any]):
         return key in self._data
 
     def __getitem__(self, key: str) -> typing.Any:
+        # If this key has been deserialized (for mutable types), we need to handle serialization
+        if hasattr(self, "_attr_to_rest_field"):
+            cache_attr = f"_deserialized_{key}"
+            if hasattr(self, cache_attr):
+                rf = _get_rest_field(getattr(self, "_attr_to_rest_field"), key)
+                if rf:
+                    value = self._data.get(key)
+                    if isinstance(value, (dict, list, set)):
+                        # For mutable types, serialize and return
+                        # But also update _data with serialized form and clear flag
+                        # so mutations via this returned value affect _data
+                        serialized = _serialize(value, rf._format)
+                        # If serialized form is same type (no transformation needed),
+                        # return _data directly so mutations work
+                        if isinstance(serialized, type(value)) and serialized == value:
+                          return self._data.get(key)
+                        # Otherwise return serialized copy and clear flag
+                        try:
+                            object.__delattr__(self, cache_attr)
+                        except AttributeError:
+                            pass
+                        # Store serialized form back
+                        self._data[key] = serialized
+                        return serialized
         return self._data.__getitem__(key)
 
     def __setitem__(self, key: str, value: typing.Any) -> None:
+        # Clear any cached deserialized value when setting through dictionary access
+        cache_attr = f"_deserialized_{key}"
+        try:
+            object.__delattr__(self, cache_attr)
+        except AttributeError:
+            pass
         self._data.__setitem__(key, value)
 
     def __delitem__(self, key: str) -> None:
@@ -886,16 +917,16 @@ def _get_deserialize_callable_from_annotation(  # pylint: disable=too-many-retur
 
     # is it optional?
     try:
-        if any(a for a in annotation.__args__ if a == type(None)):  # pyright: ignore
+        if any(a is _NONE_TYPE for a in annotation.__args__):  # pyright: ignore
             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
+                    next(a for a in annotation.__args__ if a is not _NONE_TYPE), 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
+            annotation_copy.__args__ = [a for a in annotation_copy.__args__ if a is not _NONE_TYPE]  # pyright: ignore
             return _get_deserialize_callable_from_annotation(annotation_copy, module, rf)
     except AttributeError:
         pass
@@ -1093,14 +1124,37 @@ class _RestField:
     def __get__(self, obj: Model, type=None):  # pylint: disable=redefined-builtin
         # by this point, type and rest_name will have a value bc we default
         # them in __new__ of the Model class
-        item = obj.get(self._rest_name)
+        # Use _data.get() directly to avoid triggering __getitem__ which clears the cache
+        item = obj._data.get(self._rest_name)
         if item is None:
             return item
         if self._is_model:
             return item
-        return _deserialize(self._type, _serialize(item, self._format), rf=self)
+
+        # For mutable types, we want mutations to directly affect _data
+        # Check if we've already deserialized this value
+        cache_attr = f"_deserialized_{self._rest_name}"
+        if hasattr(obj, cache_attr):
+            # Return the value from _data directly (it's been deserialized in place)
+            return obj._data.get(self._rest_name)
+
+        deserialized = _deserialize(self._type, _serialize(item, self._format), rf=self)
+
+        # For mutable types, store the deserialized value back in _data
+        # so mutations directly affect _data
+        if isinstance(deserialized, (dict, list, set)):
+            obj._data[self._rest_name] = deserialized
+            object.__setattr__(obj, cache_attr, True)  # Mark as deserialized
+            return deserialized
+
+        return deserialized
 
     def __set__(self, obj: Model, value) -> None:
+        # Clear the cached deserialized object when setting a new value
+        cache_attr = f"_deserialized_{self._rest_name}"
+        if hasattr(obj, cache_attr):
+            object.__delattr__(obj, cache_attr)
+
         if value is None:
             # we want to wipe out entries if users set attr to None
             try:
@@ -1274,7 +1328,7 @@ def _get_wrapped_element(
         _get_element(v, exclude_readonly, meta, wrapped_element)
     else:
         wrapped_element.text = _get_primitive_type_value(v)
-    return wrapped_element
+    return wrapped_element  # type: ignore[no-any-return]
 
 
 def _get_primitive_type_value(v) -> str:
@@ -1287,7 +1341,9 @@ def _get_primitive_type_value(v) -> str:
     return str(v)
 
 
-def _create_xml_element(tag, prefix=None, ns=None):
+def _create_xml_element(
+  tag: typing.Any, prefix: typing.Optional[str] = None, ns: typing.Optional[str] = None
+) -> ET.Element:
     if prefix and ns:
         ET.register_namespace(prefix, ns)
     if ns:

package/generator/pygen/codegen/templates/serialization.py.jinja2

@@ -817,13 +817,20 @@ class Serializer:  # pylint: disable=too-many-public-methods
         :param str data_type: Type of object in the iterable.
         :rtype: str, int, float, bool
         :return: serialized object
+        :raises TypeError: raise if data_type is not one of str, int, float, bool.
         """
         custom_serializer = cls._get_custom_serializers(data_type, **kwargs)
         if custom_serializer:
             return custom_serializer(data)
         if data_type == "str":
             return cls.serialize_unicode(data)
-        return eval(data_type)(data)  # nosec # pylint: disable=eval-used
+        if data_type == "int":
+            return int(data)
+        if data_type == "float":
+            return float(data)
+        if data_type == "bool":
+            return bool(data)
+        raise TypeError("Unknown basic data type: {}".format(data_type))
 
     @classmethod
     def serialize_unicode(cls, data):
@@ -1753,7 +1760,7 @@ class Deserializer:
         :param str data_type: deserialization data type.
         :return: Deserialized basic type.
         :rtype: str, int, float or bool
-        :raises TypeError: if string format is not valid.
+        :raises TypeError: if string format is not valid or data_type is not one of str, int, float, bool.
         """
         # If we're here, data is supposed to be a basic type.
         # If it's still an XML node, take the text
@@ -1779,7 +1786,11 @@ class Deserializer:
 
         if data_type == "str":
             return self.deserialize_unicode(attr)
-        return eval(data_type)(attr)  # nosec # pylint: disable=eval-used
+        if data_type == "int":
+            return int(attr)
+        if data_type == "float":
+            return float(attr)
+        raise TypeError("Unknown basic data type: {}".format(data_type))
 
     @staticmethod
     def deserialize_unicode(data):

package/generator/test/azure/mock_api_tests/asynctests/test_azure_client_generator_core_client_default_value_async.py

@@ -0,0 +1,46 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import pytest
+from specs.azure.clientgenerator.core.clientdefaultvalue.aio import ClientDefaultValueClient
+from specs.azure.clientgenerator.core.clientdefaultvalue.models import ModelWithDefaultValues
+
+
+@pytest.fixture
+async def client():
+    async with ClientDefaultValueClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_put_model_property(client: ClientDefaultValueClient):
+    """Test case 1: @clientDefaultValue for model property."""
+    body = ModelWithDefaultValues(name="test")
+    result = await client.put_model_property(body=body)
+    assert result.name == "test"
+    assert result.timeout == 30
+    assert result.tier == "standard"
+    assert result.retry is True
+
+
+@pytest.mark.asyncio
+async def test_get_operation_parameter(client: ClientDefaultValueClient):
+    """Test case 2: @clientDefaultValue for operation parameter."""
+    # Test with only required parameter (name), defaults should be applied
+    await client.get_operation_parameter(name="test")
+
+
+@pytest.mark.asyncio
+async def test_get_path_parameter(client: ClientDefaultValueClient):
+    """Test case 3: @clientDefaultValue for first path segment."""
+    # Test with only required segment2, segment1 should use default
+    await client.get_path_parameter(segment2="segment2")
+
+
+@pytest.mark.asyncio
+async def test_get_header_parameter(client: ClientDefaultValueClient):
+    """Test case 4: @clientDefaultValue for header parameters."""
+    # Test with default header values
+    await client.get_header_parameter()

package/generator/test/azure/mock_api_tests/asynctests/test_azure_client_generator_core_client_location_async.py

@@ -4,52 +4,79 @@
 # license information.
 # --------------------------------------------------------------------------
 import pytest
-from specs.azure.clientgenerator.core.clientlocation.aio import ClientLocationClient
+from specs.azure.clientgenerator.core.clientlocation.parameter.aio import MoveMethodParameterToClient
+from specs.azure.clientgenerator.core.clientlocation.subclient.aio import MoveToExistingSubClient
+from specs.azure.clientgenerator.core.clientlocation.newsubclient.aio import MoveToNewSubClient
+from specs.azure.clientgenerator.core.clientlocation.rootclient.aio import MoveToRootClient
 
 
 @pytest.fixture
-async def client():
-    async with ClientLocationClient(storage_account="testaccount") as client:
+async def move_method_parameter_to_client():
+    async with MoveMethodParameterToClient(storage_account="testaccount") as client:
+        yield client
+
+
+@pytest.fixture
+async def move_to_existing_sub_client():
+    async with MoveToExistingSubClient() as client:
+        yield client
+
+
+@pytest.fixture
+async def move_to_new_sub_client():
+    async with MoveToNewSubClient() as client:
+        yield client
+
+
+@pytest.fixture
+async def move_to_root_client():
+    async with MoveToRootClient() as client:
         yield client
 
 
 @pytest.mark.asyncio
-async def test_get_health_status(client: ClientLocationClient):
-    await client.get_health_status()
+async def test_move_method_parameter_to_client_blob_operations_get_blob(
+    move_method_parameter_to_client: MoveMethodParameterToClient,
+):
+    await move_method_parameter_to_client.blob_operations.get_blob(container="testcontainer", blob="testblob.txt")
 
 
 @pytest.mark.asyncio
-async def test_archive_operations_archive_product(client: ClientLocationClient):
-    await client.archive_operations.archive_product()
+async def test_move_to_existing_sub_client_user_operations_get_user(
+    move_to_existing_sub_client: MoveToExistingSubClient,
+):
+    await move_to_existing_sub_client.user_operations.get_user()
 
 
 @pytest.mark.asyncio
-async def test_move_to_existing_sub_client_admin_operations_get_admin_info(client: ClientLocationClient):
-    await client.move_to_existing_sub_client.admin_operations.get_admin_info()
+async def test_move_to_existing_sub_client_admin_operations_delete_user(
+    move_to_existing_sub_client: MoveToExistingSubClient,
+):
+    await move_to_existing_sub_client.admin_operations.delete_user()
 
 
 @pytest.mark.asyncio
-async def test_move_to_existing_sub_client_admin_operations_delete_user(client: ClientLocationClient):
-    await client.move_to_existing_sub_client.admin_operations.delete_user()
+async def test_move_to_existing_sub_client_admin_operations_get_admin_info(
+    move_to_existing_sub_client: MoveToExistingSubClient,
+):
+    await move_to_existing_sub_client.admin_operations.get_admin_info()
 
 
 @pytest.mark.asyncio
-async def test_move_to_existing_sub_client_user_operations_get_user(client: ClientLocationClient):
-    await client.move_to_existing_sub_client.user_operations.get_user()
+async def test_move_to_new_sub_client_product_operations_list_products(move_to_new_sub_client: MoveToNewSubClient):
+    await move_to_new_sub_client.product_operations.list_products()
 
 
 @pytest.mark.asyncio
-async def test_move_to_new_sub_client_product_operations_list_products(client: ClientLocationClient):
-    await client.move_to_new_sub_client.product_operations.list_products()
+async def test_move_to_new_sub_client_archive_operations_archive_product(move_to_new_sub_client: MoveToNewSubClient):
+    await move_to_new_sub_client.archive_operations.archive_product()
 
 
 @pytest.mark.asyncio
-async def test_move_to_root_client_resource_operations_get_resource(client: ClientLocationClient):
-    await client.move_to_root_client.resource_operations.get_resource()
+async def test_move_to_root_client_resource_operations_get_resource(move_to_root_client: MoveToRootClient):
+    await move_to_root_client.resource_operations.get_resource()
 
 
 @pytest.mark.asyncio
-async def test_move_method_parameter_to_client_blob_operations_get_blob(client: ClientLocationClient):
-    await client.move_method_parameter_to_client.blob_operations.get_blob(
-        container="testcontainer", blob="testblob.txt"
-    )
+async def test_move_to_root_client_get_health_status(move_to_root_client: MoveToRootClient):
+    await move_to_root_client.get_health_status()

package/generator/test/azure/mock_api_tests/asynctests/test_azure_resource_manager_multi_service_async.py

@@ -0,0 +1,110 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import pytest
+from azure.core.exceptions import HttpResponseError
+from azure.resourcemanager.multiservice.combined.aio import CombinedClient
+from azure.resourcemanager.multiservice.combined.models import VirtualMachine, Disk
+
+
+@pytest.fixture
+async def client(credential, authentication_policy):
+    """Create a Combined async client for testing."""
+    return CombinedClient(
+        credential=credential,
+        subscription_id="00000000-0000-0000-0000-000000000000",
+        base_url="http://localhost:3000",
+        authentication_policy=authentication_policy,
+        polling_interval=0.1,  # Speed up tests by reducing polling interval
+    )
+
+
+@pytest.mark.asyncio
+async def test_virtual_machines_get(client):
+    resource_group_name = "test-rg"
+    vm_name = "vm1"
+
+    with pytest.raises(HttpResponseError):
+        await client.virtual_machines.get(
+            resource_group_name=resource_group_name,
+            vm_name=vm_name,
+            api_version="av1",  # invalid api version shall raise error
+        )
+
+    result = await client.virtual_machines.get(resource_group_name=resource_group_name, vm_name=vm_name)
+
+    assert result is not None
+    assert isinstance(result, VirtualMachine)
+    assert result.name == vm_name
+
+
+@pytest.mark.asyncio
+async def test_virtual_machines_create_or_update(client):
+    resource_group_name = "test-rg"
+    vm_name = "vm1"
+
+    vm_resource = VirtualMachine(location="eastus", properties={})
+
+    with pytest.raises(HttpResponseError):
+        poller = await client.virtual_machines.begin_create_or_update(
+            resource_group_name=resource_group_name,
+            vm_name=vm_name,
+            resource=vm_resource,
+            api_version="av1",  # invalid api version shall raise error
+        )
+        await poller.result()
+
+    poller = await client.virtual_machines.begin_create_or_update(
+        resource_group_name=resource_group_name, vm_name=vm_name, resource=vm_resource
+    )
+
+    result = await poller.result()
+    assert result is not None
+    assert isinstance(result, VirtualMachine)
+    assert result.location == "eastus"
+
+
+@pytest.mark.asyncio
+async def test_disks_get(client):
+    resource_group_name = "test-rg"
+    disk_name = "disk1"
+    with pytest.raises(HttpResponseError):
+        await client.disks.get(
+            resource_group_name=resource_group_name,
+            disk_name=disk_name,
+            api_version="av1",  # invalid api version shall raise error
+        )
+
+    result = await client.disks.get(resource_group_name=resource_group_name, disk_name=disk_name)
+
+    assert result is not None
+    assert isinstance(result, Disk)
+    assert result.name == disk_name
+
+
+@pytest.mark.asyncio
+async def test_disks_create_or_update(client):
+    resource_group_name = "test-rg"
+    disk_name = "disk1"
+
+    disk_resource = Disk(location="eastus", properties={})
+
+    with pytest.raises(HttpResponseError):
+        poller = await client.disks.begin_create_or_update(
+            resource_group_name=resource_group_name,
+            disk_name=disk_name,
+            resource=disk_resource,
+            api_version="av1",  # invalid api version shall raise error
+        )
+        await poller.result()
+
+    poller = await client.disks.begin_create_or_update(
+        resource_group_name=resource_group_name, disk_name=disk_name, resource=disk_resource
+    )
+
+    result = await poller.result()
+    assert result is not None
+    assert isinstance(result, Disk)
+    assert result.location == "eastus"