@typespec/http-client-python 0.28.2 → 0.28.3

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

@@ -1,32 +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.model.usage import models
-from typetest.model.usage.aio import UsageClient
-
-
-@pytest.fixture
-async def client():
-    async with UsageClient() as client:
-        yield client
-
-
-@pytest.mark.asyncio
-async def test_input(client: UsageClient):
-    input = models.InputRecord(required_prop="example-value")
-    assert await client.input(input) is None
-
-
-@pytest.mark.asyncio
-async def test_output(client: UsageClient):
-    output = models.OutputRecord(required_prop="example-value")
-    assert output == await client.output()
-
-
-@pytest.mark.asyncio
-async def test_input_and_output(client: UsageClient):
-    input_output = models.InputOutputRecord(required_prop="example-value")
-    assert input_output == await client.input_and_output(input_output)

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

@@ -1,47 +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.model.visibility.aio import VisibilityClient
-from typetest.model.visibility import models
-
-
-@pytest.fixture
-async def client():
-    async with VisibilityClient() as client:
-        yield client
-
-
-@pytest.mark.asyncio
-async def test_get_model(client):
-    result = await client.get_model(models.VisibilityModel(), query_prop=123)
-    assert result == models.VisibilityModel(read_prop="abc")
-
-
-@pytest.mark.asyncio
-async def test_put_model(client):
-    await client.put_model(models.VisibilityModel(create_prop=["foo", "bar"], update_prop=[1, 2]))
-
-
-@pytest.mark.asyncio
-async def test_patch_model(client):
-    await client.patch_model(models.VisibilityModel(update_prop=[1, 2]))
-
-
-@pytest.mark.asyncio
-async def test_post_model(client):
-    await client.post_model(models.VisibilityModel(create_prop=["foo", "bar"]))
-
-
-@pytest.mark.asyncio
-async def test_delete_model(client):
-    await client.delete_model(models.VisibilityModel(delete_prop=True))
-
-
-@pytest.mark.asyncio
-async def test_put_read_only_model(client):
-    await client.put_read_only_model(
-        models.ReadOnlyModel(optional_nullable_int_list=[1, 2], optional_string_record={"foo", "bar"})
-    )

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

@@ -1,353 +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.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.skip(reason="https://github.com/microsoft/typespec/pull/6425")
-@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

@@ -1,110 +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 json
-import pytest
-from typetest.property.nullable import models
-from typetest.property.nullable.aio import NullableClient
-from typetest.property.nullable._utils.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)