@typespec/http-client-python 0.28.2 → 0.28.3

package/generator/test/generic_mock_api_tests/asynctests/test_typetest_property_optional_async.py

@@ -1,197 +0,0 @@
-# cspell: ignore Hdvcmxk
-# -------------------------------------------------------------------------
-# 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 Any
-import pytest
-from typetest.property.optional import models
-from typetest.property.optional.aio import OptionalClient
-
-
-@pytest.fixture
-async def client():
-    async with OptionalClient() as client:
-        yield client
-
-
-@pytest.mark.asyncio
-async def test_boolean_literal(client):
-    body = models.BooleanLiteralProperty(property=True)
-    assert await client.boolean_literal.get_all() == body
-    assert await client.boolean_literal.get_default() == models.BooleanLiteralProperty()
-    await client.boolean_literal.put_all(body)
-    await client.boolean_literal.put_default(models.BooleanLiteralProperty())
-
-
-@pytest.mark.asyncio
-async def test_bytes(client):
-    body = models.BytesProperty(property="aGVsbG8sIHdvcmxkIQ==")
-    assert await client.bytes.get_all() == body
-    assert await client.bytes.get_default() == models.BytesProperty()
-    await client.bytes.put_all(body)
-    await client.bytes.put_default(models.BytesProperty())
-
-
-@pytest.mark.asyncio
-async def test_collections_byte(client):
-    body = models.CollectionsByteProperty(property=["aGVsbG8sIHdvcmxkIQ==", "aGVsbG8sIHdvcmxkIQ=="])
-    assert await client.collections_byte.get_all() == body
-    assert await client.collections_byte.get_default() == models.CollectionsByteProperty()
-    await client.collections_byte.put_all(body)
-    await client.collections_byte.put_default(models.CollectionsByteProperty())
-
-
-@pytest.mark.asyncio
-async def test_collections_model(client):
-    body = models.CollectionsModelProperty(
-        property=[
-            models.StringProperty(property="hello"),
-            models.StringProperty(property="world"),
-        ]
-    )
-    assert await client.collections_model.get_all() == body
-    assert await client.collections_model.get_default() == models.CollectionsModelProperty()
-    await client.collections_model.put_all(body)
-    await client.collections_model.put_default(models.CollectionsModelProperty())
-
-
-@pytest.mark.asyncio
-async def test_datetime(client):
-    body = models.DatetimeProperty(property="2022-08-26T18:38:00Z")
-    assert await client.datetime.get_all() == body
-    assert await client.datetime.get_default() == models.DatetimeProperty()
-    await client.datetime.put_all(body)
-    await client.datetime.put_default(models.DatetimeProperty())
-
-
-@pytest.mark.asyncio
-async def test_duration(client):
-    body = models.DurationProperty(property="P123DT22H14M12.011S")
-    assert await client.duration.get_all() == body
-    assert await client.duration.get_default() == models.DurationProperty()
-    await client.duration.put_all(body)
-    await client.duration.put_default(models.DurationProperty())
-
-
-@pytest.mark.asyncio
-async def test_float_literal(client):
-    body = models.FloatLiteralProperty(property=1.25)
-    assert await client.float_literal.get_all() == body
-    assert await client.float_literal.get_default() == models.FloatLiteralProperty()
-    await client.float_literal.put_all(body)
-    await client.float_literal.put_default(models.FloatLiteralProperty())
-
-
-@pytest.mark.asyncio
-async def test_int_literal(client):
-    body = models.IntLiteralProperty(property=1)
-    assert await client.int_literal.get_all() == body
-    assert await client.int_literal.get_default() == models.IntLiteralProperty()
-    await client.int_literal.put_all(body)
-    await client.int_literal.put_default(models.IntLiteralProperty())
-
-
-@pytest.mark.asyncio
-async def test_plaindate(client):
-    body = models.PlainDateProperty(property="2022-12-12")
-    assert await client.plain_date.get_all() == body
-
-
-@pytest.mark.asyncio
-async def test_plaindate(client):
-    assert await client.plain_date.get_default() == models.PlainDateProperty()
-
-
-@pytest.mark.asyncio
-async def test_plaindate(client):
-    body = models.PlainDateProperty(property="2022-12-12")
-    await client.plain_date.put_all(body)
-
-
-@pytest.mark.asyncio
-async def test_plaindate(client):
-    await client.plain_date.put_default(models.PlainDateProperty())
-
-
-@pytest.mark.asyncio
-async def test_plaintime(client):
-    body = models.PlainTimeProperty(property="13:06:12")
-    assert await client.plain_time.get_all() == body
-
-
-@pytest.mark.asyncio
-async def test_plaintime(client):
-    assert await client.plain_time.get_default() == models.PlainTimeProperty()
-
-
-@pytest.mark.asyncio
-async def test_plaintime(client):
-    body = models.PlainTimeProperty(property="13:06:12")
-    await client.plain_time.put_all(body)
-
-
-@pytest.mark.asyncio
-async def test_plaintime(client):
-    await client.plain_time.put_default(models.PlainTimeProperty())
-
-
-@pytest.mark.asyncio
-async def test_required_and_optional(client):
-    all_body = {
-        "optionalProperty": "hello",
-        "requiredProperty": 42,
-    }
-    required_only_body = {
-        "requiredProperty": 42,
-    }
-    assert await client.required_and_optional.get_all() == all_body
-    assert await client.required_and_optional.get_required_only() == required_only_body
-    await client.required_and_optional.put_all(all_body)
-    await client.required_and_optional.put_required_only(required_only_body)
-
-
-@pytest.mark.asyncio
-async def test_string(client):
-    body = models.StringProperty(property="hello")
-    assert await client.string.get_all() == body
-    assert await client.string.get_default() == models.StringProperty()
-    await client.string.put_all(body)
-    await client.string.put_default(models.StringProperty())
-
-
-@pytest.mark.asyncio
-async def test_string_literal(client):
-    body = models.StringLiteralProperty(property="hello")
-    assert await client.string_literal.get_all() == body
-    assert await client.string_literal.get_default() == models.StringLiteralProperty()
-    await client.string_literal.put_all(body)
-    await client.string_literal.put_default(models.StringLiteralProperty())
-
-
-@pytest.mark.asyncio
-async def test_union_float_literal(client):
-    body = models.UnionFloatLiteralProperty(property=2.375)
-    assert await client.union_float_literal.get_all() == body
-    assert await client.union_float_literal.get_default() == models.UnionFloatLiteralProperty()
-    await client.union_float_literal.put_all(body)
-    await client.union_float_literal.put_default(models.UnionFloatLiteralProperty())
-
-
-@pytest.mark.asyncio
-async def test_union_int_literal(client):
-    body = models.UnionIntLiteralProperty(property=2)
-    assert await client.union_int_literal.get_all() == body
-    assert await client.union_int_literal.get_default() == models.UnionIntLiteralProperty()
-    await client.union_int_literal.put_all(body)
-    await client.union_int_literal.put_default(models.UnionIntLiteralProperty())
-
-
-@pytest.mark.asyncio
-async def test_union_string_literal(client):
-    body = models.UnionStringLiteralProperty(property="world")
-    assert await client.union_string_literal.get_all() == body
-    assert await client.union_string_literal.get_default() == models.UnionStringLiteralProperty()
-    await client.union_string_literal.put_all(body)
-    await client.union_string_literal.put_default(models.UnionStringLiteralProperty())

package/generator/test/generic_mock_api_tests/asynctests/test_typetest_property_valuetypes_async.py

@@ -1,315 +0,0 @@
-# cspell: ignore Hdvcmxk
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-import decimal
-
-import pytest
-import datetime
-from typetest.property.valuetypes import models
-from typetest.property.valuetypes.aio import ValueTypesClient
-
-
-@pytest.fixture
-async def client():
-    async with ValueTypesClient() as client:
-        yield client
-
-
-@pytest.mark.asyncio
-async def test_boolean(client: ValueTypesClient):
-    body = models.BooleanProperty(property=True)
-    assert body.property == body["property"]
-    await client.boolean.put(body)
-
-    resp = await client.boolean.get()
-    assert resp.property == resp["property"] == True
-
-
-@pytest.mark.asyncio
-async def test_boolean_literal(client: ValueTypesClient):
-    body = models.BooleanLiteralProperty(property=True)
-    assert body.property == body["property"]
-    await client.boolean_literal.put(body)
-
-    resp = await client.boolean_literal.get()
-    assert resp.property == resp["property"] == True
-
-
-@pytest.mark.asyncio
-async def test_bytes(client: ValueTypesClient):
-    body = models.BytesProperty(property=b"hello, world!")
-    assert body.property == b"hello, world!"
-    assert body["property"] == "aGVsbG8sIHdvcmxkIQ=="
-    await client.bytes.put(body)
-
-    resp = await client.bytes.get()
-    assert resp.property == b"hello, world!"
-    assert resp["property"] == "aGVsbG8sIHdvcmxkIQ=="
-
-
-@pytest.mark.asyncio
-async def test_collections_int(client: ValueTypesClient):
-    body = models.CollectionsIntProperty(property=[1, 2])
-    assert body.property == body["property"]
-    await client.collections_int.put(body)
-
-    resp = await client.collections_int.get()
-    assert resp.property == resp["property"] == [1, 2]
-
-
-@pytest.mark.asyncio
-async def test_collections_model(client: ValueTypesClient):
-    body = models.CollectionsModelProperty(property=[{"property": "hello"}, {"property": "world"}])
-    assert body.property[0].property == body["property"][0]["property"]
-    await client.collections_model.put(body)
-
-    resp = await client.collections_model.get()
-    assert resp.property[1].property == resp["property"][1]["property"]
-
-
-@pytest.mark.asyncio
-async def test_collections_string(client: ValueTypesClient):
-    body = models.CollectionsStringProperty(property=["hello", "world"])
-    assert body.property == body["property"]
-    await client.collections_string.put(body)
-
-    resp = await client.collections_string.get()
-    assert resp.property == resp["property"] == ["hello", "world"]
-
-
-@pytest.mark.asyncio
-async def test_datetime(client):
-    received_body = await client.datetime.get()
-    assert received_body == {"property": "2022-08-26T18:38:00Z"}
-    assert received_body.property.year == 2022
-    assert received_body.property.month == 8
-    assert received_body.property.day == 26
-    assert received_body.property.hour == 18
-    assert received_body.property.minute == 38
-
-    await client.datetime.put(models.DatetimeProperty(property=datetime.datetime(2022, 8, 26, hour=18, minute=38)))
-
-
-@pytest.mark.asyncio
-async def test_decimal(client: ValueTypesClient):
-    body = models.DecimalProperty(property=decimal.Decimal("0.33333"))
-    assert body.property == decimal.Decimal("0.33333")
-    assert body["property"] == 0.33333
-    await client.decimal.put(body)
-
-    resp = await client.decimal.get()
-    assert resp.property == decimal.Decimal("0.33333")
-    assert resp["property"] == 0.33333
-
-
-@pytest.mark.asyncio
-async def test_decimal128(client: ValueTypesClient):
-    body = models.Decimal128Property(property=decimal.Decimal("0.33333"))
-    assert body.property == decimal.Decimal("0.33333")
-    assert body["property"] == 0.33333
-    await client.decimal128.put(body)
-
-    resp = await client.decimal128.get()
-    assert resp.property == decimal.Decimal("0.33333")
-    assert resp["property"] == 0.33333
-
-
-@pytest.mark.asyncio
-async def test_dictionary_string(client: ValueTypesClient):
-    body = models.DictionaryStringProperty(property={"k1": "hello", "k2": "world"})
-    assert body.property == body["property"]
-    await client.dictionary_string.put(body)
-
-    resp = await client.dictionary_string.get()
-    assert resp.property == resp["property"] == {"k1": "hello", "k2": "world"}
-
-
-@pytest.mark.asyncio
-async def test_duration(client: ValueTypesClient):
-    body = models.DurationProperty(property="P123DT22H14M12.011S")
-    assert body.property == datetime.timedelta(days=123, seconds=80052, microseconds=11000)
-    assert body["property"] == "P123DT22H14M12.011S"
-    await client.duration.put(body)
-
-    resp = await client.duration.get()
-    assert resp.property == datetime.timedelta(days=123, seconds=80052, microseconds=11000)
-    assert resp["property"] == "P123DT22H14M12.011S"
-
-
-@pytest.mark.asyncio
-async def test_enum(client: ValueTypesClient):
-    body = models.EnumProperty(property=models.InnerEnum.VALUE_ONE)
-    assert body.property == body["property"]
-    await client.enum.put(body)
-
-    resp = await client.enum.get()
-    assert resp.property == resp["property"] == "ValueOne"
-
-
-@pytest.mark.asyncio
-async def test_extensible_enum(client: ValueTypesClient):
-    body = models.ExtensibleEnumProperty(property="UnknownValue")
-    assert body.property == body["property"]
-    await client.extensible_enum.put(body)
-
-    resp = await client.extensible_enum.get()
-    assert resp.property == resp["property"] == "UnknownValue"
-
-
-@pytest.mark.asyncio
-async def test_float(client: ValueTypesClient):
-    body = models.FloatProperty(property=43.125)
-    assert body.property == body["property"]
-    await client.float.put(body)
-
-    resp = await client.float.get()
-    assert resp.property == resp["property"] == 43.125
-
-
-@pytest.mark.asyncio
-async def test_float_literal(client: ValueTypesClient):
-    body = models.FloatLiteralProperty(property=43.125)
-    assert body.property == body["property"]
-    await client.float_literal.put(body)
-
-    resp = await client.float_literal.get()
-    assert resp.property == resp["property"] == 43.125
-
-
-@pytest.mark.asyncio
-async def test_int(client: ValueTypesClient):
-    body = models.IntProperty(property=42)
-    assert body.property == body["property"]
-    await client.int_operations.put(body)
-
-    resp = await client.int_operations.get()
-    assert resp.property == resp["property"] == 42
-
-
-@pytest.mark.asyncio
-async def test_int_literal(client: ValueTypesClient):
-    body = models.IntLiteralProperty(property=42)
-    assert body.property == body["property"]
-    await client.int_literal.put(body)
-
-    resp = await client.int_literal.get()
-    assert resp.property == resp["property"] == 42
-
-
-@pytest.mark.asyncio
-async def test_model(client: ValueTypesClient):
-    body = models.ModelProperty(property={"property": "hello"})
-    assert body.property.property == body["property"]["property"]
-    await client.model.put(body)
-
-    resp = await client.model.get()
-    assert resp.property.property == resp["property"]["property"]
-
-
-@pytest.mark.asyncio
-async def test_never(client: ValueTypesClient):
-    assert await client.never.get() == models.NeverProperty()
-    await client.never.put(models.NeverProperty())
-
-
-@pytest.mark.asyncio
-async def test_string(client: ValueTypesClient):
-    body = models.StringProperty(property="hello")
-    assert body.property == body["property"]
-    await client.string.put(body)
-
-    resp = await client.string.get()
-    assert resp.property == resp["property"] == "hello"
-
-
-@pytest.mark.asyncio
-async def test_string_literal(client: ValueTypesClient):
-    body = models.StringLiteralProperty(property="hello")
-    assert body.property == body["property"]
-    await client.string_literal.put(body)
-
-    resp = await client.string_literal.get()
-    assert resp.property == resp["property"] == "hello"
-
-
-@pytest.mark.asyncio
-async def test_union_enum_value(client: ValueTypesClient):
-    body = models.UnionEnumValueProperty(property=models.ExtendedEnum.ENUM_VALUE2)
-    assert body.property == body["property"]
-    await client.union_enum_value.put(body)
-
-    resp = await client.union_enum_value.get()
-    assert resp.property == resp["property"] == "value2"
-
-
-@pytest.mark.asyncio
-async def test_union_float_literal(client: ValueTypesClient):
-    body = models.UnionFloatLiteralProperty(property=46.875)
-    assert body.property == body["property"]
-    await client.union_float_literal.put(body)
-
-    resp = await client.union_float_literal.get()
-    assert resp.property == resp["property"] == 46.875
-
-
-@pytest.mark.asyncio
-async def test_union_int_literal(client: ValueTypesClient):
-    body = models.UnionIntLiteralProperty(property=42)
-    assert body.property == body["property"]
-    await client.union_int_literal.put(body)
-
-    resp = await client.union_int_literal.get()
-    assert resp.property == resp["property"] == 42
-
-
-@pytest.mark.asyncio
-async def test_union_string_literal(client: ValueTypesClient):
-    body = models.UnionStringLiteralProperty(property="world")
-    assert body.property == body["property"]
-    await client.union_string_literal.put(body)
-
-    resp = await client.union_string_literal.get()
-    assert resp.property == resp["property"] == "world"
-
-
-@pytest.mark.asyncio
-async def test_unknown_array(client: ValueTypesClient):
-    body = models.UnknownArrayProperty(property=["hello", "world"])
-    assert body.property == body["property"]
-    await client.unknown_array.put(body)
-
-    resp = await client.unknown_array.get()
-    assert resp.property == resp["property"] == ["hello", "world"]
-
-
-@pytest.mark.asyncio
-async def test_unknown_dict(client: ValueTypesClient):
-    body = models.UnknownDictProperty(property={"k1": "hello", "k2": 42})
-    assert body.property == body["property"]
-    await client.unknown_dict.put(body)
-
-    resp = await client.unknown_dict.get()
-    assert resp.property == resp["property"] == {"k1": "hello", "k2": 42}
-
-
-@pytest.mark.asyncio
-async def test_unknown_int(client: ValueTypesClient):
-    body = models.UnknownIntProperty(property=42)
-    assert body.property == body["property"]
-    await client.unknown_int.put(body)
-
-    resp = await client.unknown_int.get()
-    assert resp.property == resp["property"] == 42
-
-
-@pytest.mark.asyncio
-async def test_unknown_string(client: ValueTypesClient):
-    body = models.UnknownStringProperty(property="hello")
-    assert body.property == body["property"]
-    await client.unknown_string.put(body)
-
-    resp = await client.unknown_string.get()
-    assert resp.property == resp["property"] == "hello"

package/generator/test/generic_mock_api_tests/asynctests/test_typetest_scalar_async.py

@@ -1,60 +0,0 @@
-# -------------------------------------------------------------------------
-# Copyright (c) Microsoft Corporation. All rights reserved.
-# Licensed under the MIT License. See License.txt in the project root for
-# license information.
-# --------------------------------------------------------------------------
-import decimal
-from functools import reduce
-
-import pytest
-from typetest.scalar.aio import ScalarClient
-
-
-@pytest.fixture
-async def client():
-    async with ScalarClient() as client:
-        yield client
-
-
-@pytest.mark.asyncio
-async def test_scalar_string(client: ScalarClient):
-    assert await client.string.get() == "test"
-    await client.string.put("test")
-
-
-@pytest.mark.asyncio
-async def test_scalar_boolean(client: ScalarClient):
-    assert await client.boolean.get() == True
-    await client.boolean.put(True)
-
-
-@pytest.mark.asyncio
-async def test_scalar_unknown(client: ScalarClient):
-    assert await client.unknown.get() == "test"
-    await client.unknown.put("test")
-
-
-@pytest.mark.asyncio
-async def test_decimal128_type(client: ScalarClient):
-    assert await client.decimal128_type.response_body() == decimal.Decimal("0.33333")
-    await client.decimal128_type.request_body(decimal.Decimal("0.33333"))
-    await client.decimal128_type.request_parameter(value=decimal.Decimal("0.33333"))
-
-
-@pytest.mark.asyncio
-async def test_decimal_type(client: ScalarClient):
-    assert await client.decimal_type.response_body() == decimal.Decimal("0.33333")
-    await client.decimal_type.request_body(decimal.Decimal("0.33333"))
-    await client.decimal_type.request_parameter(value=decimal.Decimal("0.33333"))
-
-
-@pytest.mark.asyncio
-async def test_decimal128_verify(client: ScalarClient):
-    prepare = await client.decimal128_verify.prepare_verify()
-    await client.decimal128_verify.verify(reduce(lambda x, y: x + y, prepare))
-
-
-@pytest.mark.asyncio
-async def test_decimal_verify(client: ScalarClient):
-    prepare = await client.decimal_verify.prepare_verify()
-    await client.decimal_verify.verify(reduce(lambda x, y: x + y, prepare))

package/generator/test/generic_mock_api_tests/asynctests/test_typetest_union_async.py

@@ -1,90 +0,0 @@
-# -------------------------------------------------------------------------
-# 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 typetest.union.aio import UnionClient
-from typetest.union import models
-
-
-@pytest.fixture
-async def client():
-    async with UnionClient() as client:
-        yield client
-
-
-@pytest.mark.asyncio
-async def test_enums_only(client: UnionClient):
-    value = models.EnumsOnlyCases(lr="right", ud="up")
-    assert (await client.enums_only.get()) == {"prop": value}
-    await client.enums_only.send(prop=value)
-
-
-@pytest.mark.asyncio
-async def test_floats_only(client: UnionClient):
-    value = 2.2
-    assert (await client.floats_only.get()) == {"prop": value}
-    await client.floats_only.send(prop=value)
-
-
-@pytest.mark.asyncio
-async def test_ints_only(client: UnionClient):
-    value = 2
-    assert (await client.ints_only.get()) == {"prop": value}
-    await client.ints_only.send(prop=value)
-
-
-@pytest.mark.asyncio
-async def test_mixed_literals(client: UnionClient):
-    value = models.MixedLiteralsCases(string_literal="a", int_literal=2, float_literal=3.3, boolean_literal=True)
-    assert (await client.mixed_literals.get()) == {"prop": value}
-    await client.mixed_literals.send(prop=value)
-
-
-@pytest.mark.asyncio
-async def test_mixed_types(client: UnionClient):
-    value = models.MixedTypesCases(
-        model=models.Cat(name="test"),
-        literal="a",
-        int_property=2,
-        boolean=True,
-        array=[models.Cat(name="test"), "a", 2, True],
-    )
-    assert (await client.mixed_types.get()) == {"prop": value}
-    await client.mixed_types.send(prop=value)
-
-
-@pytest.mark.asyncio
-async def test_models_only(client: UnionClient):
-    value = models.Cat(name="test")
-    assert (await client.models_only.get()) == {"prop": value}
-    await client.models_only.send(prop=value)
-
-
-@pytest.mark.asyncio
-async def test_string_and_array(client: UnionClient):
-    value = models.StringAndArrayCases(string="test", array=["test1", "test2"])
-    assert (await client.string_and_array.get()) == {"prop": value}
-    await client.string_and_array.send(prop=value)
-
-
-@pytest.mark.asyncio
-async def test_string_extensible(client: UnionClient):
-    value = "custom"
-    assert (await client.string_extensible.get()) == {"prop": value}
-    await client.string_extensible.send(prop=value)
-
-
-@pytest.mark.asyncio
-async def test_string_extensible_named(client: UnionClient):
-    value = "custom"
-    assert (await client.string_extensible_named.get()) == {"prop": value}
-    await client.string_extensible_named.send(prop=value)
-
-
-@pytest.mark.asyncio
-async def test_strings_only(client: UnionClient):
-    value = "b"
-    assert (await client.strings_only.get()) == {"prop": value}
-    await client.strings_only.send(prop=value)

package/generator/test/generic_mock_api_tests/asynctests/test_versioning_added_async.py

@@ -1,36 +0,0 @@
-# -------------------------------------------------------------------------
-# 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 versioning.added.aio import AddedClient
-from versioning.added.models import ModelV1, ModelV2, EnumV1, EnumV2
-
-
-@pytest.fixture
-async def client():
-    async with AddedClient(endpoint="http://localhost:3000", version="v2") as client:
-        yield client
-
-
-@pytest.mark.asyncio
-async def test_v1(client: AddedClient):
-    assert await client.v1(
-        ModelV1(prop="foo", enum_prop=EnumV1.ENUM_MEMBER_V2, union_prop=10),
-        header_v2="bar",
-    ) == ModelV1(prop="foo", enum_prop=EnumV1.ENUM_MEMBER_V2, union_prop=10)
-
-
-@pytest.mark.asyncio
-async def test_v2(client: AddedClient):
-    assert await client.v2(ModelV2(prop="foo", enum_prop=EnumV2.ENUM_MEMBER, union_prop="bar")) == ModelV2(
-        prop="foo", enum_prop=EnumV2.ENUM_MEMBER, union_prop="bar"
-    )
-
-
-@pytest.mark.asyncio
-async def test_interface_v2(client: AddedClient):
-    assert await client.interface_v2.v2_in_interface(
-        ModelV2(prop="foo", enum_prop=EnumV2.ENUM_MEMBER, union_prop="bar")
-    ) == ModelV2(prop="foo", enum_prop=EnumV2.ENUM_MEMBER, union_prop="bar")