@typespec/http-client-python 0.1.0

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

@@ -0,0 +1,284 @@
+# -------------------------------------------------------------------------
+# 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.resourcemanager.models.resources.aio import ResourcesClient
+from azure.resourcemanager.models.resources import models
+
+SUBSCRIPTION_ID = "00000000-0000-0000-0000-000000000000"
+RESOURCE_GROUP_NAME = "test-rg"
+
+
+@pytest.fixture
+async def client(credential, authentication_policy):
+    async with ResourcesClient(
+        credential, SUBSCRIPTION_ID, "http://localhost:3000", authentication_policy=authentication_policy
+    ) as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_client_signature(credential, authentication_policy):
+    # make sure signautre order is correct
+    client1 = ResourcesClient(
+        credential, SUBSCRIPTION_ID, "http://localhost:3000", authentication_policy=authentication_policy
+    )
+    # make sure signautre name is correct
+    client2 = ResourcesClient(
+        credential=credential,
+        subscription_id=SUBSCRIPTION_ID,
+        base_url="http://localhost:3000",
+        authentication_policy=authentication_policy,
+    )
+    for client in [client1, client2]:
+        # make sure signautre order is correct
+        await client.top_level_tracked_resources.get(RESOURCE_GROUP_NAME, "top")
+        # make sure signautre name is correct
+        await client.top_level_tracked_resources.get(
+            resource_group_name=RESOURCE_GROUP_NAME, top_level_tracked_resource_name="top"
+        )
+
+
+@pytest.mark.asyncio
+async def test_top_level_tracked_resources_begin_create_or_replace(client):
+    result = await (
+        await client.top_level_tracked_resources.begin_create_or_replace(
+            resource_group_name=RESOURCE_GROUP_NAME,
+            top_level_tracked_resource_name="top",
+            resource=models.TopLevelTrackedResource(
+                location="eastus",
+                properties=models.TopLevelTrackedResourceProperties(
+                    models.TopLevelTrackedResourceProperties(description="valid")
+                ),
+            ),
+            polling_interval=0,  # set polling_interval to 0 s to make the test faster since default is 30s
+        )
+    ).result()
+    assert result.location == "eastus"
+    assert result.properties.description == "valid"
+    assert result.properties.provisioning_state == "Succeeded"
+    assert result.name == "top"
+    assert result.type == "Azure.ResourceManager.Models.Resources/topLevelTrackedResources"
+    assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_top_level_tracked_resources_begin_update(client):
+    result = await (
+        await client.top_level_tracked_resources.begin_update(
+            resource_group_name=RESOURCE_GROUP_NAME,
+            top_level_tracked_resource_name="top",
+            properties=models.TopLevelTrackedResource(
+                location="eastus",
+                properties=models.TopLevelTrackedResourceProperties(
+                    models.TopLevelTrackedResourceProperties(description="valid2")
+                ),
+            ),
+            polling_interval=0,  # set polling_interval to 0 s to make the test faster since default is 30s
+        )
+    ).result()
+    assert result.location == "eastus"
+    assert result.properties.description == "valid2"
+    assert result.properties.provisioning_state == "Succeeded"
+    assert result.name == "top"
+    assert result.type == "Azure.ResourceManager.Models.Resources/topLevelTrackedResources"
+    assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_top_level_tracked_resources_begin_delete(client):
+    await (
+        await client.top_level_tracked_resources.begin_delete(
+            resource_group_name=RESOURCE_GROUP_NAME,
+            top_level_tracked_resource_name="top",
+            polling_interval=0,  # set polling_interval to 0 s to make the test faster since default is 30s
+        )
+    ).result()
+
+
+@pytest.mark.asyncio
+async def test_top_level_tracked_resources_list_by_resource_group(client):
+    response = client.top_level_tracked_resources.list_by_resource_group(
+        resource_group_name=RESOURCE_GROUP_NAME,
+    )
+    result = [r async for r in response]
+    for result in result:
+        assert result.location == "eastus"
+        assert result.properties.description == "valid"
+        assert result.properties.provisioning_state == "Succeeded"
+        assert result.name == "top"
+        assert result.type == "Azure.ResourceManager.Models.Resources/topLevelTrackedResources"
+        assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_top_level_tracked_resources_list_by_subscription(client):
+    response = client.top_level_tracked_resources.list_by_subscription()
+    result = [r async for r in response]
+    for result in result:
+        assert result.location == "eastus"
+        assert result.properties.description == "valid"
+        assert result.properties.provisioning_state == "Succeeded"
+        assert result.name == "top"
+        assert result.type == "Azure.ResourceManager.Models.Resources/topLevelTrackedResources"
+        assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_nested_proxy_resources_get(client):
+    result = await client.nested_proxy_resources.get(
+        resource_group_name=RESOURCE_GROUP_NAME,
+        top_level_tracked_resource_name="top",
+        nexted_proxy_resource_name="nested",
+    )
+    assert result.properties.description == "valid"
+    assert result.properties.provisioning_state == "Succeeded"
+    assert result.name == "nested"
+    assert result.type == "Azure.ResourceManager.Models.Resources/topLevelTrackedResources/top/nestedProxyResources"
+    assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_nested_proxy_resources_begin_create_or_replace(client):
+    result = await (
+        await client.nested_proxy_resources.begin_create_or_replace(
+            resource_group_name=RESOURCE_GROUP_NAME,
+            top_level_tracked_resource_name="top",
+            nexted_proxy_resource_name="nested",
+            resource=models.TopLevelTrackedResource(
+                properties=models.TopLevelTrackedResourceProperties(
+                    models.TopLevelTrackedResourceProperties(description="valid")
+                ),
+            ),
+            polling_interval=0,  # set polling_interval to 0 s to make the test faster since default is 30s
+        )
+    ).result()
+    assert result.properties.description == "valid"
+    assert result.properties.provisioning_state == "Succeeded"
+    assert result.name == "nested"
+    assert result.type == "Azure.ResourceManager.Models.Resources/topLevelTrackedResources/top/nestedProxyResources"
+    assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_nested_proxy_resources_begin_update(client):
+    result = await (
+        await client.nested_proxy_resources.begin_update(
+            resource_group_name=RESOURCE_GROUP_NAME,
+            top_level_tracked_resource_name="top",
+            nexted_proxy_resource_name="nested",
+            properties=models.TopLevelTrackedResource(
+                properties=models.TopLevelTrackedResourceProperties(
+                    models.TopLevelTrackedResourceProperties(description="valid2")
+                ),
+            ),
+            polling_interval=0,  # set polling_interval to 0 s to make the test faster since default is 30s
+        )
+    ).result()
+    assert result.properties.description == "valid2"
+    assert result.properties.provisioning_state == "Succeeded"
+    assert result.name == "nested"
+    assert result.type == "Azure.ResourceManager.Models.Resources/topLevelTrackedResources/top/nestedProxyResources"
+    assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_nested_proxy_resources_begin_delete(client):
+    await (
+        await client.nested_proxy_resources.begin_delete(
+            resource_group_name=RESOURCE_GROUP_NAME,
+            top_level_tracked_resource_name="top",
+            nexted_proxy_resource_name="nested",
+            polling_interval=0,  # set polling_interval to 0 s to make the test faster since default is 30s
+        )
+    ).result()
+
+
+@pytest.mark.asyncio
+async def test_nested_proxy_resources_list_by_top_level_tracked_resource(client):
+    response = client.nested_proxy_resources.list_by_top_level_tracked_resource(
+        resource_group_name=RESOURCE_GROUP_NAME,
+        top_level_tracked_resource_name="top",
+    )
+    result = [r async for r in response]
+    for result in result:
+        assert result.properties.description == "valid"
+        assert result.properties.provisioning_state == "Succeeded"
+        assert result.name == "nested"
+        assert result.type == "Azure.ResourceManager.Models.Resources/topLevelTrackedResources/top/nestedProxyResources"
+        assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_top_level_tracked_resources_action_sync(client):
+    await client.top_level_tracked_resources.action_sync(
+        resource_group_name=RESOURCE_GROUP_NAME,
+        top_level_tracked_resource_name="top",
+        body={"message": "Resource action at top level.", "urgent": True},
+    )
+
+
+@pytest.mark.asyncio
+async def test_singleton_tracked_resources_get_by_resource_group(client):
+    result = await client.singleton_tracked_resources.get_by_resource_group(
+        resource_group_name=RESOURCE_GROUP_NAME,
+    )
+    assert result.properties.description == "valid"
+    assert result.properties.provisioning_state == "Succeeded"
+    assert result.name == "default"
+    assert result.type == "Azure.ResourceManager.Models.Resources/singletonTrackedResources"
+    assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_singleton_tracked_resources_begin_create_or_replace(client):
+    result = await (
+        await client.singleton_tracked_resources.begin_create_or_update(
+            resource_group_name=RESOURCE_GROUP_NAME,
+            resource=models.SingletonTrackedResource(
+                location="eastus",
+                properties=models.SingletonTrackedResourceProperties(
+                    models.SingletonTrackedResourceProperties(description="valid")
+                ),
+            ),
+        )
+    ).result()
+    assert result.properties.description == "valid"
+    assert result.properties.provisioning_state == "Succeeded"
+    assert result.name == "default"
+    assert result.type == "Azure.ResourceManager.Models.Resources/singletonTrackedResources"
+    assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_singleton_tracked_resources_update(client):
+    result = await client.singleton_tracked_resources.update(
+        resource_group_name=RESOURCE_GROUP_NAME,
+        properties=models.SingletonTrackedResource(
+            location="eastus2",
+            properties=models.SingletonTrackedResourceProperties(
+                models.SingletonTrackedResourceProperties(description="valid2")
+            ),
+        ),
+    )
+    assert result.properties.description == "valid2"
+    assert result.properties.provisioning_state == "Succeeded"
+    assert result.name == "default"
+    assert result.type == "Azure.ResourceManager.Models.Resources/singletonTrackedResources"
+    assert result.system_data.created_by == "AzureSDK"
+
+
+@pytest.mark.asyncio
+async def test_singleton_tracked_resources_list_by_resource_group(client):
+    response = client.singleton_tracked_resources.list_by_resource_group(
+        resource_group_name=RESOURCE_GROUP_NAME,
+    )
+    result = [r async for r in response]
+    for result in result:
+        assert result.properties.description == "valid"
+        assert result.properties.provisioning_state == "Succeeded"
+        assert result.name == "default"
+        assert result.type == "Azure.ResourceManager.Models.Resources/singletonTrackedResources"
+        assert result.system_data.created_by == "AzureSDK"

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

@@ -0,0 +1,101 @@
+# -------------------------------------------------------------------------
+# 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.access.aio import AccessClient
+from specs.azure.clientgenerator.core.access import models
+
+
+@pytest.fixture
+async def client():
+    async with AccessClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_no_decorator_in_public(client: AccessClient):
+    result = await client.public_operation.no_decorator_in_public(name="test")
+    assert result == models.NoDecoratorModelInPublic(name="test")
+
+
+@pytest.mark.asyncio
+async def test_public_decorator_in_public(client: AccessClient):
+    result = await client.public_operation.public_decorator_in_public(name="test")
+    assert result == models.PublicDecoratorModelInPublic(name="test")
+
+
+@pytest.mark.asyncio
+async def test_no_decorator_in_internal(client: AccessClient):
+    result = await client.internal_operation._no_decorator_in_internal(name="test")
+    assert result == models._models.NoDecoratorModelInInternal(name="test")
+
+    with pytest.raises(ImportError):
+        from specs.azure.clientgenerator.core.access.models import NoDecoratorModelInInternal
+
+    with pytest.raises(AttributeError):
+        await client.internal_operation.no_decorator_in_internal(name="test")
+
+
+@pytest.mark.asyncio
+async def test_internal_decorator_in_internal(client: AccessClient):
+    result = await client.internal_operation._internal_decorator_in_internal(name="test")
+    assert result == models._models.InternalDecoratorModelInInternal(name="test")
+
+    with pytest.raises(ImportError):
+        from specs.azure.clientgenerator.core.access.models import InternalDecoratorModelInInternal
+
+    with pytest.raises(AttributeError):
+        await client.internal_operation.internal_decorator_in_internal(name="test")
+
+
+@pytest.mark.asyncio
+async def test_public_decorator_in_internal(client: AccessClient):
+    result = await client.internal_operation._public_decorator_in_internal(name="test")
+    assert result == models.PublicDecoratorModelInInternal(name="test")
+
+    with pytest.raises(AttributeError):
+        await client.internal_operation.public_decorator_in_internal(name="test")
+
+
+@pytest.mark.asyncio
+async def test_public(client: AccessClient):
+    result = await client.shared_model_in_operation.public(name="test")
+    assert result == models.SharedModel(name="test")
+
+
+@pytest.mark.asyncio
+async def test_internal(client: AccessClient):
+    result = await client.shared_model_in_operation._internal(name="test")
+    assert result == models.SharedModel(name="test")
+
+    with pytest.raises(AttributeError):
+        await client.shared_model_in_operation.internal(name="test")
+
+
+@pytest.mark.asyncio
+async def test_operation(client: AccessClient):
+    result = await client.relative_model_in_operation._operation(name="test")
+    assert result == models._models.OuterModel(name="Madge", inner=models._models.InnerModel(name="Madge"))
+
+    with pytest.raises(ImportError):
+        from specs.azure.clientgenerator.core.access.models import OuterModel
+
+    with pytest.raises(ImportError):
+        from specs.azure.clientgenerator.core.access.models import InnerModel
+
+    with pytest.raises(AttributeError):
+        await client.shared_model_in_operation.operation(name="test")
+
+
+@pytest.mark.asyncio
+async def test_discriminator(client: AccessClient):
+    result = await client.relative_model_in_operation._discriminator(kind="real")
+    assert result == models._models.RealModel(name="Madge", kind="real")
+
+    with pytest.raises(ImportError):
+        from specs.azure.clientgenerator.core.access.models import RealModel
+
+    with pytest.raises(AttributeError):
+        await client.shared_model_in_operation.discriminator(kind="real")

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

@@ -0,0 +1,93 @@
+# -------------------------------------------------------------------------
+# 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.flattenproperty.aio import FlattenPropertyClient
+from specs.azure.clientgenerator.core.flattenproperty.models import (
+    FlattenModel,
+    ChildModel,
+    NestedFlattenModel,
+    ChildFlattenModel,
+)
+
+
+@pytest.fixture
+async def client():
+    async with FlattenPropertyClient() as client:
+        yield client
+
+
+# ========== test for cadl-ranch ==========
+
+
+@pytest.mark.asyncio
+async def test_put_flatten_model(client: FlattenPropertyClient):
+    resp = FlattenModel(name="test", properties=ChildModel(age=1, description="test"))
+    assert (
+        await client.put_flatten_model(FlattenModel(name="foo", properties=ChildModel(age=10, description="bar")))
+        == resp
+    )
+    assert await client.put_flatten_model(FlattenModel(name="foo", age=10, description="bar")) == resp
+
+
+@pytest.mark.asyncio
+async def test_put_nested_flatten_model(client: FlattenPropertyClient):
+    # python doesn't support nested flatten model
+    assert await client.put_nested_flatten_model(
+        NestedFlattenModel(
+            name="foo",
+            properties=ChildFlattenModel(summary="bar", properties=ChildModel(age=10, description="test")),
+        )
+    ) == NestedFlattenModel(
+        name="test",
+        properties=ChildFlattenModel(summary="test", properties=ChildModel(age=1, description="foo")),
+    )
+
+
+@pytest.mark.asyncio  # ============test for compatibility ============
+async def test_dpg_model_common():
+    flatten_model = FlattenModel(name="hello", properties=ChildModel(age=0, description="test"))
+    assert flatten_model.name == "hello"
+    assert flatten_model.properties.age == 0
+    assert flatten_model.properties.description == "test"
+
+
+@pytest.mark.asyncio
+async def test_dpg_model_none():
+    flatten_model = FlattenModel()
+    assert flatten_model.name is None
+    assert flatten_model.properties is None
+    assert flatten_model.age is None
+    assert flatten_model.description is None
+
+
+@pytest.mark.asyncio
+async def test_dpg_model_compatibility():
+    flatten_model = FlattenModel(description="test", age=0)
+    assert flatten_model.description == "test"
+    assert flatten_model.age == 0
+    assert flatten_model.properties.description == "test"
+    assert flatten_model.properties.age == 0
+
+
+@pytest.mark.asyncio
+async def test_dpg_model_setattr():
+    flatten_model = FlattenModel()
+
+    flatten_model.age = 0
+    assert flatten_model.properties.age == 0
+    flatten_model.description = "test"
+    assert flatten_model.properties.description == "test"
+
+    flatten_model.properties.age = 1
+    assert flatten_model.age == 1
+    flatten_model.properties.description = "test2"
+    assert flatten_model.description == "test2"
+
+
+@pytest.mark.asyncio
+async def test_dpg_model_exception():
+    with pytest.raises(AttributeError):
+        FlattenModel().no_prop

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

@@ -0,0 +1,31 @@
+# -------------------------------------------------------------------------
+# 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.usage.aio import UsageClient
+from specs.azure.clientgenerator.core.usage import models
+
+
+@pytest.fixture
+async def client():
+    async with UsageClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_input_to_input_output(client: UsageClient):
+    await client.model_in_operation.input_to_input_output(models.InputModel(name="Madge"))
+
+
+@pytest.mark.asyncio
+async def test_output_to_input_output(client: UsageClient):
+    assert models.OutputModel(name="Madge") == await client.model_in_operation.output_to_input_output()
+
+
+@pytest.mark.asyncio
+async def test_model_usage(client: UsageClient):
+    assert models.RoundTripModel(
+        result=models.ResultModel(name="Madge")
+    ) == await client.model_in_operation.model_in_read_only_property(body=models.RoundTripModel())

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

@@ -0,0 +1,76 @@
+# -------------------------------------------------------------------------
+# 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.core.basic import models, aio
+
+VALID_USER = models.User(id=1, name="Madge", etag="11bdc430-65e8-45ad-81d9-8ffa60d55b59")
+
+
+@pytest.fixture
+async def client():
+    async with aio.BasicClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_create_or_update(client: aio.BasicClient):
+    result = await client.create_or_update(id=1, resource={"name": "Madge"})
+    assert result == VALID_USER
+
+
+@pytest.mark.asyncio
+async def test_create_or_replace(client: aio.BasicClient):
+    result = await client.create_or_replace(id=1, resource={"name": "Madge"})
+    assert result == VALID_USER
+
+
+@pytest.mark.asyncio
+async def test_get(client: aio.BasicClient):
+    result = await client.get(id=1)
+    assert result == VALID_USER
+
+
+@pytest.mark.asyncio
+async def test_list(client: aio.BasicClient):
+    result = client.list(
+        top=5,
+        skip=10,
+        orderby=["id"],
+        filter="id lt 10",
+        select=["id", "orders", "etag"],
+        expand=["orders"],
+    )
+    result = [item async for item in result]
+    assert len(result) == 2
+    assert result[0].id == 1
+    assert result[0].name == "Madge"
+    assert result[0].etag == "11bdc430-65e8-45ad-81d9-8ffa60d55b59"
+    assert result[0].orders[0].id == 1
+    assert result[0].orders[0].user_id == 1
+    assert result[0].orders[0].detail == "a recorder"
+    assert result[1].id == 2
+    assert result[1].name == "John"
+    assert result[1].etag == "11bdc430-65e8-45ad-81d9-8ffa60d55b5a"
+    assert result[1].orders[0].id == 2
+    assert result[1].orders[0].user_id == 2
+    assert result[1].orders[0].detail == "a TV"
+
+
+@pytest.mark.asyncio
+async def test_delete(client: aio.BasicClient):
+    await client.delete(id=1)
+
+
+@pytest.mark.asyncio
+async def test_export(client: aio.BasicClient):
+    result = await client.export(id=1, format="json")
+    assert result == VALID_USER
+
+
+@pytest.mark.asyncio
+async def test_export_all_users(client: aio.BasicClient):
+    result = await client.export_all_users(format="json")
+    assert result.users[0] == VALID_USER

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

@@ -0,0 +1,22 @@
+# -------------------------------------------------------------------------
+# 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 azurecore.lro.rpc.aio import RpcClient
+from azurecore.lro.rpc import models
+
+
+@pytest.fixture
+async def client():
+    async with RpcClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_long_running_rpc(client: RpcClient, async_polling_method):
+    result = await client.begin_long_running_rpc(
+        models.GenerationOptions(prompt="text"), polling_interval=0, polling=async_polling_method
+    )
+    assert (await result.result()) == models.GenerationResult(data="text data")

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

@@ -0,0 +1,39 @@
+# -------------------------------------------------------------------------
+# 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.core.lro.standard.aio import StandardClient
+from specs.azure.core.lro.standard.models import User, ExportedUser
+
+
+@pytest.fixture
+async def client():
+    async with StandardClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_lro_core_put(client, async_polling_method):
+    user = User({"name": "madge", "role": "contributor"})
+    result = await (
+        await client.begin_create_or_replace(
+            name=user.name, resource=user, polling_interval=0, polling=async_polling_method
+        )
+    ).result()
+    assert result == user
+
+
+@pytest.mark.asyncio
+async def test_lro_core_delete(client, async_polling_method):
+    await (await client.begin_delete(name="madge", polling_interval=0, polling=async_polling_method)).result()
+
+
+@pytest.mark.asyncio
+async def test_lro_core_export(client, async_polling_method):
+    export_user = ExportedUser({"name": "madge", "resourceUri": "/users/madge"})
+    result = await (
+        await client.begin_export(name="madge", format="json", polling_interval=0, polling=async_polling_method)
+    ).result()
+    assert result == export_user

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

@@ -0,0 +1,33 @@
+# -------------------------------------------------------------------------
+# 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.core.model.aio import ModelClient
+from specs.azure.core.model.models import AzureEmbeddingModel
+
+
+@pytest.fixture
+async def client():
+    async with ModelClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_azure_core_embedding_vector_post(client: ModelClient):
+    embedding_model = AzureEmbeddingModel(embedding=[0, 1, 2, 3, 4])
+    result = await client.azure_core_embedding_vector.post(
+        body=embedding_model,
+    )
+    assert result == AzureEmbeddingModel(embedding=[5, 6, 7, 8, 9])
+
+
+@pytest.mark.asyncio
+async def test_azure_core_embedding_vector_put(client: ModelClient):
+    await client.azure_core_embedding_vector.put(body=[0, 1, 2, 3, 4])
+
+
+@pytest.mark.asyncio
+async def test_azure_core_embedding_vector_get(client: ModelClient):
+    assert [0, 1, 2, 3, 4] == (await client.azure_core_embedding_vector.get())