@typespec/http-client-python 0.1.0

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

@@ -0,0 +1,118 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+
+import pytest
+import isodate
+from typetest.array.aio import ArrayClient
+from typetest.array import models
+
+
+@pytest.fixture
+async def client():
+    async with ArrayClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_boolean_value(client: ArrayClient):
+    assert await client.boolean_value.get() == [True, False]
+    await client.boolean_value.put([True, False])
+
+
+@pytest.mark.asyncio
+async def test_datetime_value(client: ArrayClient):
+    assert await client.datetime_value.get() == [isodate.parse_datetime("2022-08-26T18:38:00Z")]
+    await client.datetime_value.put([isodate.parse_datetime("2022-08-26T18:38:00Z")])
+
+
+@pytest.mark.asyncio
+async def test_duration_value(client: ArrayClient):
+    assert await client.duration_value.get() == [isodate.parse_duration("P123DT22H14M12.011S")]
+    await client.duration_value.put([isodate.parse_duration("P123DT22H14M12.011S")])
+
+
+@pytest.mark.asyncio
+async def test_float32_value(client: ArrayClient):
+    assert await client.float32_value.get() == [43.125]
+    await client.float32_value.put([43.125])
+
+
+@pytest.mark.asyncio
+async def test_int32_value(client: ArrayClient):
+    assert await client.int32_value.get() == [1, 2]
+    await client.int32_value.put([1, 2])
+
+
+@pytest.mark.asyncio
+async def test_int64_value(client: ArrayClient):
+    assert await client.int64_value.get() == [2**53 - 1, -(2**53 - 1)]
+    await client.int64_value.put([2**53 - 1, -(2**53 - 1)])
+
+
+@pytest.mark.asyncio
+async def test_model_value(client: ArrayClient):
+    assert await client.model_value.get() == [
+        models.InnerModel(property="hello"),
+        models.InnerModel(property="world"),
+    ]
+    await client.model_value.put(
+        [
+            models.InnerModel(property="hello"),
+            models.InnerModel(property="world"),
+        ]
+    )
+
+
+@pytest.mark.asyncio
+async def test_nullable_boolean_value(client: ArrayClient):
+    assert await client.nullable_boolean_value.get() == [True, None, False]
+    await client.nullable_boolean_value.put([True, None, False])
+
+
+@pytest.mark.asyncio
+async def test_nullable_float_value(client: ArrayClient):
+    assert await client.nullable_float_value.get() == [1.25, None, 3.0]
+    await client.nullable_float_value.put([1.25, None, 3.0])
+
+
+@pytest.mark.asyncio
+async def test_nullable_int32_value(client: ArrayClient):
+    assert await client.nullable_int32_value.get() == [1, None, 3]
+    await client.nullable_int32_value.put([1, None, 3])
+
+
+@pytest.mark.asyncio
+async def test_nullable_model_value(client: ArrayClient):
+    assert await client.nullable_model_value.get() == [
+        models.InnerModel(property="hello"),
+        None,
+        models.InnerModel(property="world"),
+    ]
+    await client.nullable_model_value.put(
+        [
+            models.InnerModel(property="hello"),
+            None,
+            models.InnerModel(property="world"),
+        ]
+    )
+
+
+@pytest.mark.asyncio
+async def test_nullable_string_value(client: ArrayClient):
+    assert await client.nullable_string_value.get() == ["hello", None, "world"]
+    await client.nullable_string_value.put(["hello", None, "world"])
+
+
+@pytest.mark.asyncio
+async def test_string_value(client: ArrayClient):
+    assert await client.string_value.get() == ["hello", ""]
+    await client.string_value.put(["hello", ""])
+
+
+@pytest.mark.asyncio
+async def test_unknown_value(client: ArrayClient):
+    assert await client.unknown_value.get() == [1, "hello", None]
+    await client.unknown_value.put([1, "hello", None])

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

@@ -0,0 +1,98 @@
+# -------------------------------------------------------------------------
+# 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.dictionary import models
+from typetest.dictionary.aio import DictionaryClient
+import isodate
+
+
+@pytest.fixture
+async def client():
+    async with DictionaryClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_boolean_value(client: DictionaryClient):
+    value = {"k1": True, "k2": False}
+    assert await client.boolean_value.get() == value
+    await client.boolean_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_datetime_value(client: DictionaryClient):
+    value = {"k1": isodate.parse_datetime("2022-08-26T18:38:00Z")}
+    assert await client.datetime_value.get() == value
+    await client.datetime_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_duration_value(client: DictionaryClient):
+    value = {"k1": isodate.parse_duration("P123DT22H14M12.011S")}
+    assert await client.duration_value.get() == value
+    await client.duration_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_float32_value(client: DictionaryClient):
+    value = {"k1": 43.125}
+    assert await client.float32_value.get() == value
+    await client.float32_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_int32_value(client: DictionaryClient):
+    value = {"k1": 1, "k2": 2}
+    assert await client.int32_value.get() == value
+    await client.int32_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_int64_value(client: DictionaryClient):
+    value = {"k1": 2**53 - 1, "k2": -(2**53 - 1)}
+    assert await client.int64_value.get() == value
+    await client.int64_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_model_value(client: DictionaryClient):
+    value = {
+        "k1": models.InnerModel(property="hello"),
+        "k2": models.InnerModel(property="world"),
+    }
+    assert await client.model_value.get() == value
+    await client.model_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_nullable_float_value(client: DictionaryClient):
+    value = {"k1": 1.25, "k2": 0.5, "k3": None}
+    assert await client.nullable_float_value.get() == value
+    await client.nullable_float_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_recursive_model_value(client: DictionaryClient):
+    value = {
+        "k1": models.InnerModel(property="hello", children={}),
+        "k2": models.InnerModel(property="world", children={"k2.1": models.InnerModel(property="inner world")}),
+    }
+    assert await client.recursive_model_value.get() == value
+    await client.recursive_model_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_string_value(client: DictionaryClient):
+    value = {"k1": "hello", "k2": ""}
+    assert await client.string_value.get() == value
+    await client.string_value.put(value)
+
+
+@pytest.mark.asyncio
+async def test_unknown_value(client: DictionaryClient):
+    value = {"k1": 1, "k2": "hello", "k3": None}
+    assert await client.unknown_value.get() == value
+    await client.unknown_value.put(value)

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

@@ -0,0 +1,25 @@
+# -------------------------------------------------------------------------
+# 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.enum.extensible import models, aio
+
+
+@pytest.fixture
+async def client():
+    async with aio.ExtensibleClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_known_value(client):
+    assert await client.string.get_known_value() == models.DaysOfWeekExtensibleEnum.MONDAY
+    await client.string.put_known_value(models.DaysOfWeekExtensibleEnum.MONDAY)
+
+
+@pytest.mark.asyncio
+async def test_unknown_value(client):
+    assert await client.string.get_unknown_value() == "Weekend"
+    await client.string.put_unknown_value("Weekend")

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

@@ -0,0 +1,27 @@
+# -------------------------------------------------------------------------
+# 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.enum.fixed import aio, models
+
+
+@pytest.fixture
+async def client():
+    async with aio.FixedClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_known_value(client):
+    assert await client.string.get_known_value() == models.DaysOfWeekEnum.MONDAY
+    await client.string.put_known_value(models.DaysOfWeekEnum.MONDAY)
+
+
+@pytest.mark.asyncio
+async def test_unknown_value(client: aio.FixedClient, core_library):
+    try:
+        await client.string.put_unknown_value("Weekend")
+    except core_library.exceptions.HttpResponseError as err:
+        assert err.status_code == 500

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

@@ -0,0 +1,32 @@
+# -------------------------------------------------------------------------
+# 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.empty.aio import EmptyClient
+from typetest.model.empty.models import EmptyInput, EmptyOutput, EmptyInputOutput
+
+
+@pytest.fixture
+async def client():
+    async with EmptyClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_put(client: EmptyClient):
+    await client.put_empty(EmptyInput())
+    await client.put_empty({})
+
+
+@pytest.mark.asyncio
+async def test_get(client: EmptyClient):
+    assert await client.get_empty() == EmptyOutput()
+    assert await client.get_empty() == {}
+
+
+@pytest.mark.asyncio
+async def test_post_round(client: EmptyClient):
+    assert await client.post_round_trip_empty(EmptyInputOutput()) == EmptyInputOutput()
+    assert await client.post_round_trip_empty({}) == {}

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

@@ -0,0 +1,70 @@
+# -------------------------------------------------------------------------
+# 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.enumdiscriminator.aio import EnumDiscriminatorClient
+from typetest.model.enumdiscriminator import models
+
+
+@pytest.fixture
+async def client():
+    async with EnumDiscriminatorClient() as client:
+        yield client
+
+
+@pytest.fixture
+def valid_body():
+    return models.Golden(weight=10)
+
+
+@pytest.fixture
+def valid_fixed_body():
+    return models.Cobra(length=10)
+
+
+@pytest.mark.asyncio
+async def test_get_extensible_model(client: EnumDiscriminatorClient, valid_body: models.Dog):
+    assert await client.get_extensible_model() == valid_body
+    assert isinstance(await client.get_extensible_model(), models.Golden)
+
+
+@pytest.mark.asyncio
+async def test_put_extensible_model(client: EnumDiscriminatorClient, valid_body: models.Dog):
+    await client.put_extensible_model(valid_body)
+
+
+@pytest.mark.asyncio
+async def test_get_extensible_model_missing_discriminator(
+    client: EnumDiscriminatorClient,
+):
+    assert await client.get_extensible_model_missing_discriminator() == models.Dog(weight=10)
+
+
+@pytest.mark.asyncio
+async def test_get_extensible_model_wrong_discriminator(
+    client: EnumDiscriminatorClient,
+):
+    assert await client.get_extensible_model_wrong_discriminator() == models.Dog(weight=8, kind="wrongKind")
+
+
+@pytest.mark.asyncio
+async def test_get_fixed_model(client: EnumDiscriminatorClient, valid_fixed_body: models.Snake):
+    assert await client.get_fixed_model() == valid_fixed_body
+    assert isinstance(await client.get_fixed_model(), models.Cobra)
+
+
+@pytest.mark.asyncio
+async def test_put_fixed_model(client: EnumDiscriminatorClient, valid_fixed_body: models.Snake):
+    await client.put_fixed_model(valid_fixed_body)
+
+
+@pytest.mark.asyncio
+async def test_get_fixed_model_missing_discriminator(client: EnumDiscriminatorClient):
+    assert await client.get_fixed_model_missing_discriminator() == models.Snake(length=10)
+
+
+@pytest.mark.asyncio
+async def test_get_fixed_model_wrong_discriminator(client: EnumDiscriminatorClient):
+    assert await client.get_fixed_model_wrong_discriminator() == models.Snake(length=8, kind="wrongKind")

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

@@ -0,0 +1,85 @@
+# -------------------------------------------------------------------------
+# 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.nesteddiscriminator.aio import NestedDiscriminatorClient
+from typetest.model.nesteddiscriminator.models import GoblinShark, Salmon, Fish
+
+
+@pytest.fixture
+async def client():
+    async with NestedDiscriminatorClient() as client:
+        yield client
+
+
+@pytest.fixture
+async def valid_body():
+    return GoblinShark(age=1)
+
+
+@pytest.mark.asyncio
+async def test_get_model(client, valid_body):
+    assert await client.get_model() == valid_body
+    assert isinstance(await client.get_model(), GoblinShark)
+
+
+@pytest.mark.asyncio
+async def test_put_model(client, valid_body):
+    await client.put_model(valid_body)
+
+
+@pytest.fixture
+async def valid_recursive_body():
+    return Salmon(
+        {
+            "age": 1,
+            "kind": "salmon",
+            "partner": {"age": 2, "kind": "shark", "sharktype": "saw"},
+            "friends": [
+                {
+                    "age": 2,
+                    "kind": "salmon",
+                    "partner": {"age": 3, "kind": "salmon"},
+                    "hate": {
+                        "key1": {"age": 4, "kind": "salmon"},
+                        "key2": {"age": 2, "kind": "shark", "sharktype": "goblin"},
+                    },
+                },
+                {"age": 3, "kind": "shark", "sharktype": "goblin"},
+            ],
+            "hate": {
+                "key3": {"age": 3, "kind": "shark", "sharktype": "saw"},
+                "key4": {
+                    "age": 2,
+                    "kind": "salmon",
+                    "friends": [
+                        {"age": 1, "kind": "salmon"},
+                        {"age": 4, "kind": "shark", "sharktype": "goblin"},
+                    ],
+                },
+            },
+        }
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_recursive_model(client, valid_recursive_body):
+    assert valid_recursive_body == await client.get_recursive_model()
+    assert isinstance(await client.get_recursive_model(), Salmon)
+
+
+@pytest.mark.asyncio
+async def test_put_recursive_model(client, valid_recursive_body):
+    await client.put_recursive_model(valid_recursive_body)
+
+
+@pytest.mark.asyncio
+async def test_get_missing_discriminator(client):
+    assert await client.get_missing_discriminator() == Fish(age=1)
+
+
+@pytest.mark.asyncio
+async def test_get_wrong_discriminator(client):
+    assert await client.get_wrong_discriminator() == Fish(age=1, kind="wrongKind")

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

@@ -0,0 +1,34 @@
+# -------------------------------------------------------------------------
+# 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.notdiscriminated.aio import NotDiscriminatedClient
+from typetest.model.notdiscriminated.models import Siamese
+
+
+@pytest.fixture
+async def client():
+    async with NotDiscriminatedClient() as client:
+        yield client
+
+
+@pytest.fixture
+async def valid_body():
+    return Siamese(name="abc", age=32, smart=True)
+
+
+@pytest.mark.asyncio
+async def test_get_valid(client, valid_body):
+    assert await client.get_valid() == valid_body
+
+
+@pytest.mark.asyncio
+async def test_post_valid(client, valid_body):
+    await client.post_valid(valid_body)
+
+
+@pytest.mark.asyncio
+async def test_put_valid(client, valid_body):
+    assert valid_body == await client.put_valid(valid_body)

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

@@ -0,0 +1,34 @@
+# -------------------------------------------------------------------------
+# 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.recursive.aio import RecursiveClient
+from typetest.model.recursive.models import Extension
+
+
+@pytest.fixture
+async def client():
+    async with RecursiveClient() as client:
+        yield client
+
+
+@pytest.fixture
+async def expected():
+    return Extension(
+        {
+            "level": 0,
+            "extension": [{"level": 1, "extension": [{"level": 2}]}, {"level": 1}],
+        }
+    )
+
+
+@pytest.mark.asyncio
+async def test_put(client: RecursiveClient, expected: Extension):
+    await client.put(expected)
+
+
+@pytest.mark.asyncio
+async def test_get(client: RecursiveClient, expected: Extension):
+    assert await client.get() == expected

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

@@ -0,0 +1,67 @@
+# -------------------------------------------------------------------------
+# 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.singlediscriminator.aio import SingleDiscriminatorClient
+from typetest.model.singlediscriminator.models import Sparrow, Eagle, Bird, Dinosaur
+
+
+@pytest.fixture
+async def client():
+    async with SingleDiscriminatorClient() as client:
+        yield client
+
+
+@pytest.fixture
+async def valid_body():
+    return Sparrow(wingspan=1)
+
+
+@pytest.mark.asyncio
+async def test_get_model(client, valid_body):
+    assert await client.get_model() == valid_body
+
+
+@pytest.mark.asyncio
+async def test_put_model(client, valid_body):
+    await client.put_model(valid_body)
+
+
+@pytest.fixture
+async def recursive_body():
+    return Eagle(
+        {
+            "wingspan": 5,
+            "kind": "eagle",
+            "partner": {"wingspan": 2, "kind": "goose"},
+            "friends": [{"wingspan": 2, "kind": "seagull"}],
+            "hate": {"key3": {"wingspan": 1, "kind": "sparrow"}},
+        }
+    )
+
+
+@pytest.mark.asyncio
+async def test_get_recursive_model(client, recursive_body):
+    assert await client.get_recursive_model() == recursive_body
+
+
+@pytest.mark.asyncio
+async def test_put_recursive_model(client, recursive_body):
+    await client.put_recursive_model(recursive_body)
+
+
+@pytest.mark.asyncio
+async def test_get_missing_discriminator(client):
+    assert await client.get_missing_discriminator() == Bird(wingspan=1)
+
+
+@pytest.mark.asyncio
+async def test_get_wrong_discriminator(client):
+    assert await client.get_wrong_discriminator() == Bird(wingspan=1, kind="wrongKind")
+
+
+@pytest.mark.asyncio
+async def test_get_legacy_model(client):
+    assert await client.get_legacy_model() == Dinosaur(size=20, kind="t-rex")

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

@@ -0,0 +1,32 @@
+# -------------------------------------------------------------------------
+# 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

@@ -0,0 +1,47 @@
+# -------------------------------------------------------------------------
+# 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"})
+    )