@typespec/http-client-python 0.1.0

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

@@ -0,0 +1,133 @@
+# -------------------------------------------------------------------------
+# 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 pathlib import Path
+from encode.bytes.aio import BytesClient
+from encode.bytes.models import (
+    DefaultBytesProperty,
+    Base64urlBytesProperty,
+    Base64BytesProperty,
+    Base64urlArrayBytesProperty,
+)
+
+
+FILE_FOLDER = Path(__file__).parent.parent
+
+
+@pytest.fixture
+async def client():
+    async with BytesClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_query(client: BytesClient):
+    await client.query.default(
+        value=bytes("test", "utf-8"),
+    )
+    await client.query.base64(
+        value=bytes("test", "utf-8"),
+    )
+    await client.query.base64_url(
+        value=bytes("test", "utf-8"),
+    )
+    await client.query.base64_url_array(
+        value=[
+            bytes("test", "utf-8"),
+            bytes("test", "utf-8"),
+        ],
+    )
+
+
+@pytest.mark.asyncio
+async def test_property(client: BytesClient):
+    result = await client.property.default(
+        DefaultBytesProperty(
+            value=bytes("test", "utf-8"),
+        )
+    )
+    assert result.value == bytes("test", "utf-8")
+
+    result = await client.property.base64(
+        Base64BytesProperty(
+            value=bytes("test", "utf-8"),
+        )
+    )
+    assert result.value == bytes("test", "utf-8")
+
+    result = await client.property.base64_url(
+        Base64urlBytesProperty(
+            value=bytes("test", "utf-8"),
+        )
+    )
+    assert result.value == bytes("test", "utf-8")
+
+    result = await client.property.base64_url_array(
+        Base64urlArrayBytesProperty(
+            value=[
+                bytes("test", "utf-8"),
+                bytes("test", "utf-8"),
+            ],
+        )
+    )
+    assert result.value == [
+        bytes("test", "utf-8"),
+        bytes("test", "utf-8"),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_header(client: BytesClient):
+    await client.header.default(
+        value=bytes("test", "utf-8"),
+    )
+    await client.header.base64(
+        value=bytes("test", "utf-8"),
+    )
+    await client.header.base64_url(
+        value=bytes("test", "utf-8"),
+    )
+    await client.header.base64_url_array(
+        value=[
+            bytes("test", "utf-8"),
+            bytes("test", "utf-8"),
+        ],
+    )
+
+
+@pytest.fixture
+def png_data() -> bytes:
+    with open(str(FILE_FOLDER / "data/image.png"), "rb") as file_in:
+        return file_in.read()
+
+
+@pytest.mark.asyncio
+async def test_request_body(client: BytesClient, png_data: bytes):
+    await client.request_body.default(
+        value=bytes("test", "utf-8"),
+    )
+    await client.request_body.octet_stream(
+        value=png_data,
+    )
+    await client.request_body.custom_content_type(
+        value=png_data,
+    )
+    await client.request_body.base64(
+        value=bytes("test", "utf-8"),
+    )
+    await client.request_body.base64_url(
+        value=bytes("test", "utf-8"),
+    )
+
+
+@pytest.mark.asyncio
+async def test_response_body(client: BytesClient, png_data: bytes):
+    expected = b"test"
+    assert expected == await client.response_body.default()
+    assert expected == await client.response_body.base64()
+    assert expected == await client.response_body.base64_url()
+    assert b"".join([d async for d in (await client.response_body.octet_stream())]) == png_data
+    assert b"".join([d async for d in (await client.response_body.custom_content_type())]) == png_data

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

@@ -0,0 +1,127 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import datetime
+
+import pytest
+from encode.datetime.aio import DatetimeClient
+from encode.datetime.models import (
+    DefaultDatetimeProperty,
+    Rfc3339DatetimeProperty,
+    Rfc7231DatetimeProperty,
+    UnixTimestampDatetimeProperty,
+    UnixTimestampArrayDatetimeProperty,
+)
+
+
+@pytest.fixture
+async def client():
+    async with DatetimeClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_query(client: DatetimeClient):
+    await client.query.default(
+        value=datetime.datetime(2022, 8, 26, 18, 38, 0, tzinfo=datetime.timezone.utc),
+    )
+    await client.query.rfc3339(
+        value=datetime.datetime(2022, 8, 26, 18, 38, 0, tzinfo=datetime.timezone.utc),
+    )
+    await client.query.rfc7231(
+        value=datetime.datetime(2022, 8, 26, 14, 38, 0, tzinfo=datetime.timezone.utc),
+    )
+    await client.query.unix_timestamp(
+        value=datetime.datetime(2023, 6, 12, 10, 47, 44, tzinfo=datetime.timezone.utc),
+    )
+    await client.query.unix_timestamp_array(
+        value=[
+            datetime.datetime(2023, 6, 12, 10, 47, 44, tzinfo=datetime.timezone.utc),
+            datetime.datetime(2023, 6, 14, 9, 17, 36, tzinfo=datetime.timezone.utc),
+        ],
+    )
+
+
+@pytest.mark.asyncio
+async def test_property(client: DatetimeClient):
+    result = await client.property.default(
+        DefaultDatetimeProperty(
+            value=datetime.datetime(2022, 8, 26, 18, 38, 0, tzinfo=datetime.timezone.utc),
+        )
+    )
+    assert result.value == datetime.datetime(2022, 8, 26, 18, 38, 0, tzinfo=datetime.timezone.utc)
+
+    result = await client.property.rfc3339(
+        Rfc3339DatetimeProperty(
+            value=datetime.datetime(2022, 8, 26, 18, 38, 0, tzinfo=datetime.timezone.utc),
+        )
+    )
+    assert result.value == datetime.datetime(2022, 8, 26, 18, 38, 0, tzinfo=datetime.timezone.utc)
+
+    result = await client.property.rfc7231(
+        Rfc7231DatetimeProperty(
+            value=datetime.datetime(2022, 8, 26, 14, 38, 0, tzinfo=datetime.timezone.utc),
+        )
+    )
+    assert result.value == datetime.datetime(2022, 8, 26, 14, 38, 0, tzinfo=datetime.timezone.utc)
+
+    result = await client.property.unix_timestamp(
+        UnixTimestampDatetimeProperty(
+            value=datetime.datetime(2023, 6, 12, 10, 47, 44, tzinfo=datetime.timezone.utc),
+        )
+    )
+    assert result.value == datetime.datetime(2023, 6, 12, 10, 47, 44, tzinfo=datetime.timezone.utc)
+
+    result = await client.property.unix_timestamp_array(
+        UnixTimestampArrayDatetimeProperty(
+            value=[
+                datetime.datetime(2023, 6, 12, 10, 47, 44, tzinfo=datetime.timezone.utc),
+                datetime.datetime(2023, 6, 14, 9, 17, 36, tzinfo=datetime.timezone.utc),
+            ],
+        )
+    )
+    assert result.value == [
+        datetime.datetime(2023, 6, 12, 10, 47, 44, tzinfo=datetime.timezone.utc),
+        datetime.datetime(2023, 6, 14, 9, 17, 36, tzinfo=datetime.timezone.utc),
+    ]
+
+
+@pytest.mark.asyncio
+async def test_header(client: DatetimeClient):
+    await client.header.default(
+        value=datetime.datetime(2022, 8, 26, 14, 38, 0, tzinfo=datetime.timezone.utc),
+    )
+    await client.header.rfc3339(
+        value=datetime.datetime(2022, 8, 26, 18, 38, 0, tzinfo=datetime.timezone.utc),
+    )
+    await client.header.rfc7231(
+        value=datetime.datetime(2022, 8, 26, 14, 38, 0, tzinfo=datetime.timezone.utc),
+    )
+    await client.header.unix_timestamp(
+        value=datetime.datetime(2023, 6, 12, 10, 47, 44, tzinfo=datetime.timezone.utc),
+    )
+    await client.header.unix_timestamp_array(
+        value=[
+            datetime.datetime(2023, 6, 12, 10, 47, 44, tzinfo=datetime.timezone.utc),
+            datetime.datetime(2023, 6, 14, 9, 17, 36, tzinfo=datetime.timezone.utc),
+        ]
+    )
+
+
+@pytest.mark.asyncio
+async def test_response_header(client: DatetimeClient):
+    cls = lambda x, y, z: z
+    assert (await client.response_header.default(cls=cls))["value"] == datetime.datetime(
+        2022, 8, 26, 14, 38, 0, tzinfo=datetime.timezone.utc
+    )
+    assert (await client.response_header.rfc3339(cls=cls))["value"] == datetime.datetime(
+        2022, 8, 26, 18, 38, 0, tzinfo=datetime.timezone.utc
+    )
+    assert (await client.response_header.rfc7231(cls=cls))["value"] == datetime.datetime(
+        2022, 8, 26, 14, 38, 0, tzinfo=datetime.timezone.utc
+    )
+    assert (await client.response_header.unix_timestamp(cls=cls))["value"] == datetime.datetime(
+        2023, 6, 12, 10, 47, 44, tzinfo=datetime.timezone.utc
+    )

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

@@ -0,0 +1,63 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import datetime
+
+import pytest
+from encode.duration.aio import DurationClient
+from encode.duration.models import (
+    Int32SecondsDurationProperty,
+    ISO8601DurationProperty,
+    FloatSecondsDurationProperty,
+    DefaultDurationProperty,
+    FloatSecondsDurationArrayProperty,
+)
+
+
+@pytest.fixture
+async def client():
+    async with DurationClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_query(client: DurationClient):
+    await client.query.default(input=datetime.timedelta(days=40))
+    await client.query.iso8601(input=datetime.timedelta(days=40))
+    await client.query.int32_seconds(input=36)
+    await client.query.int32_seconds_array(input=[36, 47])
+    await client.query.float_seconds(input=35.625)
+    await client.query.float64_seconds(input=35.625)
+
+
+@pytest.mark.asyncio
+async def test_property(client: DurationClient):
+    result = await client.property.default(DefaultDurationProperty(value=datetime.timedelta(days=40)))
+    assert result.value == datetime.timedelta(days=40)
+    result = await client.property.default(DefaultDurationProperty(value="P40D"))
+    assert result.value == datetime.timedelta(days=40)
+    result = await client.property.iso8601(ISO8601DurationProperty(value=datetime.timedelta(days=40)))
+    assert result.value == datetime.timedelta(days=40)
+    result = await client.property.iso8601(ISO8601DurationProperty(value="P40D"))
+    assert result.value == datetime.timedelta(days=40)
+    result = await client.property.int32_seconds(Int32SecondsDurationProperty(value=36))
+    assert result.value == 36
+    result = await client.property.float_seconds(FloatSecondsDurationProperty(value=35.625))
+    assert abs(result.value - 35.625) < 0.0001
+    result = await client.property.float64_seconds(FloatSecondsDurationProperty(value=35.625))
+    assert abs(result.value - 35.625) < 0.0001
+    result = await client.property.float_seconds_array(FloatSecondsDurationArrayProperty(value=[35.625, 46.75]))
+    assert abs(result.value[0] - 35.625) < 0.0001
+    assert abs(result.value[1] - 46.75) < 0.0001
+
+
+@pytest.mark.asyncio
+async def test_header(client: DurationClient):
+    await client.header.default(duration=datetime.timedelta(days=40))
+    await client.header.iso8601(duration=datetime.timedelta(days=40))
+    await client.header.iso8601_array(duration=[datetime.timedelta(days=40), datetime.timedelta(days=50)])
+    await client.header.int32_seconds(duration=36)
+    await client.header.float_seconds(duration=35.625)
+    await client.header.float64_seconds(duration=35.625)

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

@@ -0,0 +1,35 @@
+# -------------------------------------------------------------------------
+# 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 encode.numeric.aio import NumericClient
+from encode.numeric import models
+
+
+@pytest.fixture
+async def client():
+    async with NumericClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_safeint_as_string(client: NumericClient):
+    result = await client.property.safeint_as_string(models.SafeintAsStringProperty(value=10000000000))
+    assert result.value == 10000000000
+    assert result["value"] == "10000000000"
+
+
+@pytest.mark.asyncio
+async def test_uint32_as_string_optional(client: NumericClient):
+    result = await client.property.uint32_as_string_optional(models.Uint32AsStringProperty(value=1))
+    assert result.value == 1
+    assert result["value"] == "1"
+
+
+@pytest.mark.asyncio
+async def test_uint8_as_string_optional(client: NumericClient):
+    result = await client.property.uint8_as_string(models.Uint32AsStringProperty(value=255))
+    assert result.value == 255
+    assert result["value"] == "255"

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

@@ -0,0 +1,35 @@
+# -------------------------------------------------------------------------
+# 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 headasbooleantrue.aio import VisibilityClient as HeadAsBooleanTrueClient
+from headasbooleantrue import models as models_true
+
+from headasbooleanfalse.aio import VisibilityClient as HeadAsBooleanFalseClient
+from headasbooleanfalse import models as models_false
+
+
+@pytest.fixture
+async def client_true():
+    async with HeadAsBooleanTrueClient() as client:
+        yield client
+
+
+@pytest.fixture
+async def client_false():
+    async with HeadAsBooleanFalseClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_head_true(client_true):
+    body = models_true.VisibilityModel(query_prop=123)
+    assert await client_true.head_model(body) == True
+
+
+@pytest.mark.asyncio
+async def test_head_false(client_false):
+    body = models_false.VisibilityModel(query_prop=123)
+    assert await client_false.head_model(body) is None

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

@@ -0,0 +1,24 @@
+# -------------------------------------------------------------------------
+# 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 parameters.basic.aio import BasicClient
+from parameters.basic.models import User
+
+
+@pytest.fixture
+async def client():
+    async with BasicClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_explicit_simple(client: BasicClient):
+    await client.explicit_body.simple(User(name="foo"))
+
+
+@pytest.mark.asyncio
+async def test_implicit_simple(client: BasicClient):
+    await client.implicit_body.simple(name="foo")

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

@@ -0,0 +1,30 @@
+# -------------------------------------------------------------------------
+# 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 parameters.bodyoptionality.aio import BodyOptionalityClient
+from parameters.bodyoptionality.models import BodyModel
+
+
+@pytest.fixture
+async def client():
+    async with BodyOptionalityClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_required_explicit(client: BodyOptionalityClient):
+    await client.required_explicit(BodyModel(name="foo"))
+
+
+@pytest.mark.asyncio
+async def test_required_implicit(client: BodyOptionalityClient):
+    await client.required_implicit(name="foo")
+
+
+@pytest.mark.asyncio
+async def test_optional_explicit(client: BodyOptionalityClient):
+    await client.optional_explicit.set(BodyModel(name="foo"))
+    await client.optional_explicit.omit()

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

@@ -0,0 +1,44 @@
+# -------------------------------------------------------------------------
+# 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 parameters.collectionformat.aio import CollectionFormatClient
+
+
+@pytest.fixture
+async def client():
+    async with CollectionFormatClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_query_multi(client: CollectionFormatClient):
+    await client.query.multi(colors=["blue", "red", "green"])
+
+
+@pytest.mark.asyncio
+async def test_query_csv(client: CollectionFormatClient):
+    await client.query.csv(colors=["blue", "red", "green"])
+
+
+@pytest.mark.asyncio
+async def test_query_pipes(client: CollectionFormatClient):
+    await client.query.pipes(colors=["blue", "red", "green"])
+
+
+@pytest.mark.asyncio
+async def test_query_ssv(client: CollectionFormatClient):
+    await client.query.ssv(colors=["blue", "red", "green"])
+
+
+@pytest.mark.asyncio
+@pytest.mark.skip(reason="https://github.com/aio-libs/aiohttp/issues/5904")
+async def test_query_tsv(client: CollectionFormatClient):
+    await client.query.tsv(colors=["blue", "red", "green"])
+
+
+@pytest.mark.asyncio
+async def test_csv_header(client: CollectionFormatClient):
+    await client.header.csv(colors=["blue", "red", "green"])

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

@@ -0,0 +1,76 @@
+# -------------------------------------------------------------------------
+# 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 parameters.spread.aio import SpreadClient
+from parameters.spread.models import BodyParameter
+
+
+@pytest.fixture
+async def client():
+    async with SpreadClient() as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_model_body(client: SpreadClient):
+    await client.model.spread_as_request_body(name="foo")
+
+
+@pytest.mark.asyncio
+async def test_model_composite_request_only_with_body(client: SpreadClient):
+    await client.model.spread_composite_request_only_with_body(BodyParameter(name="foo"))
+
+
+@pytest.mark.asyncio
+async def test_model_composite_request_without_body(client: SpreadClient):
+    await client.model.spread_composite_request_without_body(name="foo", test_header="bar")
+
+
+@pytest.mark.asyncio
+async def test_model_composite_request(client: SpreadClient):
+    await client.model.spread_composite_request(name="foo", body=BodyParameter(name="foo"), test_header="bar")
+
+
+@pytest.mark.asyncio
+async def test_model_composite_request_mix(client: SpreadClient):
+    await client.model.spread_composite_request_mix(name="foo", prop="foo", test_header="bar")
+
+
+@pytest.mark.asyncio
+async def test_alias_body(client: SpreadClient):
+    await client.alias.spread_as_request_body(name="foo")
+
+
+@pytest.mark.asyncio
+async def test_alias_parameter(client: SpreadClient):
+    await client.alias.spread_as_request_parameter("1", x_ms_test_header="bar", name="foo")
+
+
+@pytest.mark.asyncio
+async def test_alias_multiple_parameter(client: SpreadClient):
+    await client.alias.spread_with_multiple_parameters(
+        "1",
+        x_ms_test_header="bar",
+        required_string="foo",
+        required_int_list=[1, 2],
+        optional_string_list=["foo", "bar"],
+        optional_int=1,
+    )
+    await client.alias.spread_with_multiple_parameters(
+        "1",
+        {"requiredString": "foo", "optionalInt": 1, "requiredIntList": [1, 2], "optionalStringList": ["foo", "bar"]},
+        x_ms_test_header="bar",
+    )
+
+
+@pytest.mark.asyncio
+async def test_inner_model(client: SpreadClient):
+    await client.alias.spread_parameter_with_inner_model(id="1", x_ms_test_header="bar", body={"name": "foo"})
+
+
+@pytest.mark.asyncio
+async def test_inner_alias(client: SpreadClient):
+    await client.alias.spread_parameter_with_inner_alias(id="1", x_ms_test_header="bar", body={"name": "foo", "age": 1})

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

@@ -0,0 +1,37 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+import base64
+import pytest
+from payload.contentnegotiation.aio import ContentNegotiationClient
+from payload.contentnegotiation.models import PngImageAsJson
+
+
+@pytest.fixture
+async def client():
+    async with ContentNegotiationClient(endpoint="http://localhost:3000") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_get_avatar_as_png(client: ContentNegotiationClient, png_data: bytes):
+    assert b"".join([d async for d in (await client.same_body.get_avatar_as_png())]) == png_data
+
+
+@pytest.mark.asyncio
+async def test_get_avatar_as_jpeg(client: ContentNegotiationClient, jpg_data: bytes):
+    assert b"".join([d async for d in (await client.same_body.get_avatar_as_jpeg())]) == jpg_data
+
+
+@pytest.mark.asyncio
+async def test_different_body_get_avatar_as_png(client: ContentNegotiationClient, png_data: bytes):
+    assert b"".join([d async for d in (await client.different_body.get_avatar_as_png())]) == png_data
+
+
+@pytest.mark.asyncio
+async def test_different_body_get_avatar_as_json(client: ContentNegotiationClient, png_data: bytes):
+    result = await client.different_body.get_avatar_as_json()
+    expected = PngImageAsJson(content=base64.b64encode(png_data).decode())
+    assert result == expected