@typespec/http-client-python 0.1.0

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

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

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

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

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

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

@@ -0,0 +1,21 @@
+# -------------------------------------------------------------------------
+# 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.madeoptional.aio import MadeOptionalClient
+from versioning.madeoptional.models import TestModel
+
+
+@pytest.fixture
+async def client():
+    async with MadeOptionalClient(endpoint="http://localhost:3000", version="v2") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test(client: MadeOptionalClient):
+    assert await client.test(
+        TestModel(prop="foo"),
+    ) == TestModel(prop="foo")

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

@@ -0,0 +1,21 @@
+# -------------------------------------------------------------------------
+# 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.removed.aio import RemovedClient
+from versioning.removed.models import ModelV2, EnumV2
+
+
+@pytest.fixture
+async def client():
+    async with RemovedClient(endpoint="http://localhost:3000", version="v2") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_v2(client: RemovedClient):
+    assert await client.v2(ModelV2(prop="foo", enum_prop=EnumV2.ENUM_MEMBER_V2, union_prop="bar")) == ModelV2(
+        prop="foo", enum_prop=EnumV2.ENUM_MEMBER_V2, union_prop="bar"
+    )

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

@@ -0,0 +1,29 @@
+# -------------------------------------------------------------------------
+# 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.renamedfrom.aio import RenamedFromClient
+from versioning.renamedfrom.models import NewModel, NewEnum
+
+
+@pytest.fixture
+async def client():
+    async with RenamedFromClient(endpoint="http://localhost:3000", version="v2") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_new_op(client: RenamedFromClient):
+    assert await client.new_op(
+        NewModel(new_prop="foo", enum_prop=NewEnum.NEW_ENUM_MEMBER, union_prop=10),
+        new_query="bar",
+    ) == NewModel(new_prop="foo", enum_prop=NewEnum.NEW_ENUM_MEMBER, union_prop=10)
+
+
+@pytest.mark.asyncio
+async def test_new_interface_test(client: RenamedFromClient):
+    assert await client.new_interface.new_op_in_new_interface(
+        NewModel(new_prop="foo", enum_prop=NewEnum.NEW_ENUM_MEMBER, union_prop=10)
+    ) == NewModel(new_prop="foo", enum_prop=NewEnum.NEW_ENUM_MEMBER, union_prop=10)

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

@@ -0,0 +1,18 @@
+# -------------------------------------------------------------------------
+# 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.returntypechangedfrom.aio import ReturnTypeChangedFromClient
+
+
+@pytest.fixture
+async def client():
+    async with ReturnTypeChangedFromClient(endpoint="http://localhost:3000", version="v2") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test(client: ReturnTypeChangedFromClient):
+    assert await client.test("test") == "test"

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

@@ -0,0 +1,22 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import pytest
+from versioning.typechangedfrom.aio import TypeChangedFromClient
+from versioning.typechangedfrom.models import TestModel
+
+
+@pytest.fixture
+async def client():
+    async with TypeChangedFromClient(endpoint="http://localhost:3000", version="v2") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test(client: TypeChangedFromClient):
+    assert await client.test(
+        TestModel(prop="foo", changed_prop="bar"),
+        param="baz",
+    ) == TestModel(prop="foo", changed_prop="bar")