@typespec/http-client-python 0.1.0

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

@@ -0,0 +1,352 @@
+# -------------------------------------------------------------------------
+# 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.property.additionalproperties import models
+from typetest.property.additionalproperties.aio import AdditionalPropertiesClient
+
+
+@pytest.fixture
+async def client():
+    async with AdditionalPropertiesClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_extends_different_spread_float(client: AdditionalPropertiesClient):
+    body = models.DifferentSpreadFloatDerived({"name": "abc", "prop": 43.125, "derivedProp": 43.125})
+    assert await client.extends_different_spread_float.get() == body
+    await client.extends_different_spread_float.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_different_spread_model(client: AdditionalPropertiesClient):
+    body = models.DifferentSpreadModelDerived(
+        {"knownProp": "abc", "prop": {"state": "ok"}, "derivedProp": {"state": "ok"}}
+    )
+    assert await client.extends_different_spread_model.get() == body
+    await client.extends_different_spread_model.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_different_spread_model_array(client: AdditionalPropertiesClient):
+    body = models.DifferentSpreadModelArrayDerived(
+        {
+            "knownProp": "abc",
+            "prop": [{"state": "ok"}, {"state": "ok"}],
+            "derivedProp": [{"state": "ok"}, {"state": "ok"}],
+        }
+    )
+    assert await client.extends_different_spread_model_array.get() == body
+    await client.extends_different_spread_model_array.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_different_spread_string(client: AdditionalPropertiesClient):
+    body = models.DifferentSpreadStringDerived({"id": 43.125, "prop": "abc", "derivedProp": "abc"})
+    assert await client.extends_different_spread_string.get() == body
+    await client.extends_different_spread_string.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_float(client: AdditionalPropertiesClient):
+    body = models.ExtendsFloatAdditionalProperties({"id": 43.125, "prop": 43.125})
+    assert await client.extends_float.get() == body
+    await client.extends_float.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_model(client: AdditionalPropertiesClient):
+    body = models.ExtendsModelAdditionalProperties({"knownProp": {"state": "ok"}, "prop": {"state": "ok"}})
+    assert await client.extends_model.get() == body
+    await client.extends_model.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_model_array(client: AdditionalPropertiesClient):
+    body = models.ExtendsModelArrayAdditionalProperties(
+        {
+            "knownProp": [{"state": "ok"}, {"state": "ok"}],
+            "prop": [{"state": "ok"}, {"state": "ok"}],
+        }
+    )
+    assert await client.extends_model_array.get() == body
+    await client.extends_model_array.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_string(client: AdditionalPropertiesClient):
+    body = models.ExtendsStringAdditionalProperties({"name": "ExtendsStringAdditionalProperties", "prop": "abc"})
+    assert await client.extends_string.get() == body
+    await client.extends_string.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_unknown(client: AdditionalPropertiesClient):
+    body = models.ExtendsUnknownAdditionalProperties(
+        {
+            "name": "ExtendsUnknownAdditionalProperties",
+            "prop1": 32,
+            "prop2": True,
+            "prop3": "abc",
+        }
+    )
+    assert await client.extends_unknown.get() == body
+    await client.extends_unknown.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_unknown_derived(client: AdditionalPropertiesClient):
+    body = models.ExtendsUnknownAdditionalPropertiesDerived(
+        {
+            "name": "ExtendsUnknownAdditionalProperties",
+            "index": 314,
+            "age": 2.71875,
+            "prop1": 32,
+            "prop2": True,
+            "prop3": "abc",
+        }
+    )
+    assert await client.extends_unknown_derived.get() == body
+    await client.extends_unknown_derived.put(body)
+
+
+@pytest.mark.asyncio
+async def test_extends_unknown_discriminated(client: AdditionalPropertiesClient):
+    body = models.ExtendsUnknownAdditionalPropertiesDiscriminatedDerived(
+        {
+            "kind": "derived",
+            "name": "Derived",
+            "index": 314,
+            "age": 2.71875,
+            "prop1": 32,
+            "prop2": True,
+            "prop3": "abc",
+        }
+    )
+    assert await client.extends_unknown_discriminated.get() == body
+    await client.extends_unknown_discriminated.put(body)
+
+
+@pytest.mark.asyncio
+async def test_is_float(client: AdditionalPropertiesClient):
+    body = models.IsFloatAdditionalProperties({"id": 43.125, "prop": 43.125})
+    assert await client.is_float.get() == body
+    await client.is_float.put(body)
+
+
+@pytest.mark.asyncio
+async def test_is_model(client: AdditionalPropertiesClient):
+    body = models.IsModelAdditionalProperties({"knownProp": {"state": "ok"}, "prop": {"state": "ok"}})
+    assert await client.is_model.get() == body
+    await client.is_model.put(body)
+
+
+@pytest.mark.asyncio
+async def test_is_model_array(client: AdditionalPropertiesClient):
+    body = models.IsModelArrayAdditionalProperties(
+        {
+            "knownProp": [{"state": "ok"}, {"state": "ok"}],
+            "prop": [{"state": "ok"}, {"state": "ok"}],
+        }
+    )
+    assert await client.is_model_array.get() == body
+    await client.is_model_array.put(body)
+
+
+@pytest.mark.asyncio
+async def test_is_string(client: AdditionalPropertiesClient):
+    body = models.IsStringAdditionalProperties({"name": "IsStringAdditionalProperties", "prop": "abc"})
+    assert await client.is_string.get() == body
+    await client.is_string.put(body)
+
+
+@pytest.mark.asyncio
+async def test_is_unknown(client: AdditionalPropertiesClient):
+    body = models.IsUnknownAdditionalProperties(
+        {
+            "name": "IsUnknownAdditionalProperties",
+            "prop1": 32,
+            "prop2": True,
+            "prop3": "abc",
+        }
+    )
+    assert await client.is_unknown.get() == body
+    await client.is_unknown.put(body)
+
+
+@pytest.mark.asyncio
+async def test_is_unknown_derived(client: AdditionalPropertiesClient):
+    body = models.IsUnknownAdditionalPropertiesDerived(
+        {
+            "name": "IsUnknownAdditionalProperties",
+            "index": 314,
+            "age": 2.71875,
+            "prop1": 32,
+            "prop2": True,
+            "prop3": "abc",
+        }
+    )
+    assert await client.is_unknown_derived.get() == body
+    await client.is_unknown_derived.put(body)
+
+
+@pytest.mark.asyncio
+async def test_is_unknown_discriminated(client: AdditionalPropertiesClient):
+    body = models.IsUnknownAdditionalPropertiesDiscriminatedDerived(
+        {
+            "kind": "derived",
+            "name": "Derived",
+            "index": 314,
+            "age": 2.71875,
+            "prop1": 32,
+            "prop2": True,
+            "prop3": "abc",
+        }
+    )
+    assert await client.is_unknown_discriminated.get() == body
+    await client.is_unknown_discriminated.put(body)
+
+
+@pytest.mark.asyncio
+async def test_multiple_spread(client: AdditionalPropertiesClient):
+    body = {"flag": True, "prop1": "abc", "prop2": 43.125}
+    assert await client.multiple_spread.get() == body
+    await client.multiple_spread.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_different_float(client: AdditionalPropertiesClient):
+    body = {"name": "abc", "prop": 43.125}
+    assert await client.spread_different_float.get() == body
+    await client.spread_different_float.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_different_model(client: AdditionalPropertiesClient):
+    body = {"knownProp": "abc", "prop": {"state": "ok"}}
+    assert await client.spread_different_model.get() == body
+    await client.spread_different_model.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_different_model_array(client: AdditionalPropertiesClient):
+    body = {"knownProp": "abc", "prop": [{"state": "ok"}, {"state": "ok"}]}
+    assert await client.spread_different_model_array.get() == body
+    await client.spread_different_model_array.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_different_string(client: AdditionalPropertiesClient):
+    body = {"id": 43.125, "prop": "abc"}
+    assert await client.spread_different_string.get() == body
+    await client.spread_different_string.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_model(client: AdditionalPropertiesClient):
+    body = {"knownProp": {"state": "ok"}, "prop": {"state": "ok"}}
+    assert await client.spread_model.get() == body
+    await client.spread_model.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_model_array(client: AdditionalPropertiesClient):
+    body = {
+        "knownProp": [{"state": "ok"}, {"state": "ok"}],
+        "prop": [{"state": "ok"}, {"state": "ok"}],
+    }
+    assert await client.spread_model_array.get() == body
+    await client.spread_model_array.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_record_discriminated_union(client: AdditionalPropertiesClient):
+    body = {
+        "name": "abc",
+        "prop1": {"fooProp": "abc", "kind": "kind0"},
+        "prop2": {
+            "end": "2021-01-02T00:00:00Z",
+            "kind": "kind1",
+            "start": "2021-01-01T00:00:00Z",
+        },
+    }
+    assert await client.spread_record_discriminated_union.get() == body
+    await client.spread_record_discriminated_union.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_record_non_discriminated_union(
+    client: AdditionalPropertiesClient,
+):
+    body = {
+        "name": "abc",
+        "prop1": {"kind": "kind0", "fooProp": "abc"},
+        "prop2": {
+            "kind": "kind1",
+            "start": "2021-01-01T00:00:00Z",
+            "end": "2021-01-02T00:00:00Z",
+        },
+    }
+    assert await client.spread_record_non_discriminated_union.get() == body
+    await client.spread_record_non_discriminated_union.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_record_non_discriminated_union2(
+    client: AdditionalPropertiesClient,
+):
+    body = {
+        "name": "abc",
+        "prop1": {"kind": "kind1", "start": "2021-01-01T00:00:00Z"},
+        "prop2": {
+            "kind": "kind1",
+            "start": "2021-01-01T00:00:00Z",
+            "end": "2021-01-02T00:00:00Z",
+        },
+    }
+    assert await client.spread_record_non_discriminated_union2.get() == body
+    await client.spread_record_non_discriminated_union2.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_record_non_discriminated_union3(
+    client: AdditionalPropertiesClient,
+):
+    body = {
+        "name": "abc",
+        "prop1": [
+            {"kind": "kind1", "start": "2021-01-01T00:00:00Z"},
+            {"kind": "kind1", "start": "2021-01-01T00:00:00Z"},
+        ],
+        "prop2": {
+            "kind": "kind1",
+            "start": "2021-01-01T00:00:00Z",
+            "end": "2021-01-02T00:00:00Z",
+        },
+    }
+    assert await client.spread_record_non_discriminated_union3.get() == body
+    await client.spread_record_non_discriminated_union3.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_record_union(client: AdditionalPropertiesClient):
+    body = {"flag": True, "prop1": "abc", "prop2": 43.125}
+    assert await client.spread_record_union.get() == body
+    await client.spread_record_union.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_string(client: AdditionalPropertiesClient):
+    body = {"name": "SpreadSpringRecord", "prop": "abc"}
+    assert await client.spread_string.get() == body
+    await client.spread_string.put(body)
+
+
+@pytest.mark.asyncio
+async def test_spread_float(client: AdditionalPropertiesClient):
+    body = {"id": 43.125, "prop": 43.125}
+    assert await client.spread_float.get() == body
+    await client.spread_float.put(body)

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

@@ -0,0 +1,110 @@
+# 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 json
+import pytest
+from typetest.property.nullable import models
+from typetest.property.nullable.aio import NullableClient
+from typetest.property.nullable._model_base import (  # pylint: disable=protected-access
+    SdkJSONEncoder,
+)
+
+try:
+    from corehttp.serialization import NULL
+except ImportError:
+    from azure.core.serialization import NULL
+
+
+@pytest.fixture
+async def client():
+    async with NullableClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_bytes(client: NullableClient):
+    non_null_model = models.BytesProperty(required_property="foo", nullable_property="aGVsbG8sIHdvcmxkIQ==")
+    non_model = models.BytesProperty(required_property="foo", nullable_property=NULL)
+    assert '{"requiredProperty": "foo", "nullableProperty": null}' == json.dumps(non_model, cls=SdkJSONEncoder)
+    assert await client.bytes.get_non_null() == non_null_model
+    assert (await client.bytes.get_null())["nullableProperty"] is None
+    await client.bytes.patch_non_null(body=non_null_model)
+    await client.bytes.patch_null(body=non_model)
+
+
+@pytest.mark.asyncio
+async def test_collections_byte(client: NullableClient):
+    non_null_model = models.CollectionsByteProperty(
+        required_property="foo",
+        nullable_property=["aGVsbG8sIHdvcmxkIQ==", "aGVsbG8sIHdvcmxkIQ=="],
+    )
+    non_model = models.CollectionsByteProperty(required_property="foo", nullable_property=NULL)
+    assert '{"requiredProperty": "foo", "nullableProperty": null}' == json.dumps(non_model, cls=SdkJSONEncoder)
+    assert await client.collections_byte.get_non_null() == non_null_model
+    assert (await client.collections_byte.get_null())["nullableProperty"] is None
+    await client.collections_byte.patch_non_null(body=non_null_model)
+    await client.collections_byte.patch_null(body=non_model)
+
+
+@pytest.mark.asyncio
+async def test_collections_model(client: NullableClient):
+    non_null_model = models.CollectionsModelProperty(
+        required_property="foo",
+        nullable_property=[
+            models.InnerModel(property="hello"),
+            models.InnerModel(property="world"),
+        ],
+    )
+    non_model = models.CollectionsModelProperty(required_property="foo", nullable_property=NULL)
+    assert '{"requiredProperty": "foo", "nullableProperty": null}' == json.dumps(non_model, cls=SdkJSONEncoder)
+    assert await client.collections_model.get_non_null() == non_null_model
+    assert (await client.collections_model.get_null())["nullableProperty"] is None
+    await client.collections_model.patch_non_null(body=non_null_model)
+    await client.collections_model.patch_null(body=non_model)
+
+
+@pytest.mark.asyncio
+async def test_collections_string(client: NullableClient):
+    non_null_model = models.CollectionsStringProperty(required_property="foo", nullable_property=["hello", "world"])
+    non_model = models.CollectionsStringProperty(required_property="foo", nullable_property=NULL)
+    assert '{"requiredProperty": "foo", "nullableProperty": null}' == json.dumps(non_model, cls=SdkJSONEncoder)
+    assert await client.collections_string.get_non_null() == non_null_model
+    assert (await client.collections_string.get_null())["nullableProperty"] is None
+    await client.collections_string.patch_non_null(body=non_null_model)
+    await client.collections_string.patch_null(body=non_model)
+
+
+@pytest.mark.asyncio
+async def test_datetime(client: NullableClient):
+    non_null_model = models.DatetimeProperty(required_property="foo", nullable_property="2022-08-26T18:38:00Z")
+    non_model = models.DatetimeProperty(required_property="foo", nullable_property=NULL)
+    assert '{"requiredProperty": "foo", "nullableProperty": null}' == json.dumps(non_model, cls=SdkJSONEncoder)
+    assert await client.datetime.get_non_null() == non_null_model
+    assert (await client.datetime.get_null())["nullableProperty"] is None
+    await client.datetime.patch_non_null(body=non_null_model)
+    await client.datetime.patch_null(body=non_model)
+
+
+@pytest.mark.asyncio
+async def test_duration(client: NullableClient):
+    non_null_model = models.DurationProperty(required_property="foo", nullable_property="P123DT22H14M12.011S")
+    non_model = models.DurationProperty(required_property="foo", nullable_property=NULL)
+    assert '{"requiredProperty": "foo", "nullableProperty": null}' == json.dumps(non_model, cls=SdkJSONEncoder)
+    assert await client.duration.get_non_null() == non_null_model
+    assert (await client.duration.get_null())["nullableProperty"] is None
+    await client.duration.patch_non_null(body=non_null_model)
+    await client.duration.patch_null(body=non_model)
+
+
+@pytest.mark.asyncio
+async def test_string(client: NullableClient):
+    non_null_model = models.StringProperty(required_property="foo", nullable_property="hello")
+    non_model = models.StringProperty(required_property="foo", nullable_property=NULL)
+    assert '{"requiredProperty": "foo", "nullableProperty": null}' == json.dumps(non_model, cls=SdkJSONEncoder)
+    assert await client.string.get_non_null() == non_null_model
+    assert (await client.string.get_null())["nullableProperty"] is None
+    await client.string.patch_non_null(body=non_null_model)
+    await client.string.patch_null(body=non_model)

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

@@ -0,0 +1,197 @@
+# 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())