@typespec/http-client-python 0.1.0

package/generator/test/generic_mock_api_tests/asynctests/test_payload_json_merge_patch_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 payload.jsonmergepatch.aio import JsonMergePatchClient
+from payload.jsonmergepatch.models import InnerModel, Resource, ResourcePatch
+
+try:
+    from azure.core.serialization import NULL
+except ImportError:
+    from corehttp.serialization import NULL
+
+
+@pytest.fixture
+async def client():
+    async with JsonMergePatchClient(endpoint="http://localhost:3000") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_create_resource(client: JsonMergePatchClient):
+    inner_madge = InnerModel(name="InnerMadge", description="innerDesc")
+    create_resource = Resource(
+        name="Madge",
+        description="desc",
+        map={"key": inner_madge},
+        array=[inner_madge],
+        int_value=1,
+        float_value=1.1,
+        inner_model=inner_madge,
+        int_array=[1, 2, 3],
+    )
+    response = await client.create_resource(create_resource)
+    assert response == create_resource
+
+
+@pytest.mark.asyncio
+async def test_update_resource_model_input(client: JsonMergePatchClient):
+    update_resource = ResourcePatch(
+        description=NULL,
+        map={"key": InnerModel(description=NULL), "key2": NULL},
+        array=NULL,
+        int_value=NULL,
+        float_value=NULL,
+        inner_model=NULL,
+        int_array=NULL,
+    )
+    response = await client.update_resource(update_resource)
+    assert response == Resource(name="Madge", map={"key": InnerModel(name="InnerMadge")})
+
+
+@pytest.mark.asyncio
+async def test_update_resource_raw_input(client: JsonMergePatchClient):
+    response = await client.update_resource(
+        {
+            "description": None,
+            "map": {"key": {"description": None}, "key2": None},
+            "array": None,
+            "intValue": None,
+            "floatValue": None,
+            "innerModel": None,
+            "intArray": None,
+        }
+    )
+    assert response == Resource(name="Madge", map={"key": InnerModel(name="InnerMadge")})
+
+
+@pytest.mark.asyncio
+async def test_update_optional_resource_model_input(client: JsonMergePatchClient):
+    update_resource = ResourcePatch(
+        description=NULL,
+        map={"key": InnerModel(description=NULL), "key2": NULL},
+        array=NULL,
+        int_value=NULL,
+        float_value=NULL,
+        inner_model=NULL,
+        int_array=NULL,
+    )
+    response = await client.update_optional_resource(update_resource)
+    assert response == Resource(name="Madge", map={"key": InnerModel(name="InnerMadge")})
+
+
+@pytest.mark.asyncio
+async def test_update_optional_resource_raw_input(client: JsonMergePatchClient):
+    response = await client.update_optional_resource(
+        {
+            "description": None,
+            "map": {"key": {"description": None}, "key2": None},
+            "array": None,
+            "intValue": None,
+            "floatValue": None,
+            "innerModel": None,
+            "intArray": None,
+        }
+    )
+    assert response == Resource(name="Madge", map={"key": InnerModel(name="InnerMadge")})

package/generator/test/generic_mock_api_tests/asynctests/test_payload_media_type_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 payload.mediatype.aio import MediaTypeClient
+
+
+@pytest.fixture
+async def client():
+    async with MediaTypeClient(endpoint="http://localhost:3000") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_json(client: MediaTypeClient):
+    data = "foo"
+    await client.string_body.send_as_json(data)
+    assert await client.string_body.get_as_json() == data
+
+
+@pytest.mark.asyncio
+async def test_text(client: MediaTypeClient):
+    data = "{cat}"
+    await client.string_body.send_as_text(data)
+    assert await client.string_body.get_as_text() == data

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

@@ -0,0 +1,153 @@
+# -------------------------------------------------------------------------
+# Copyright (c) Microsoft Corporation. All rights reserved.
+# Licensed under the MIT License. See License.txt in the project root for
+# license information.
+# --------------------------------------------------------------------------
+from pathlib import Path
+import pytest
+from payload.multipart import models
+from payload.multipart.aio import MultiPartClient
+
+JPG = Path(__file__).parent.parent / "data/image.jpg"
+PNG = Path(__file__).parent.parent / "data/image.png"
+
+
+@pytest.fixture
+async def client():
+    async with MultiPartClient(endpoint="http://localhost:3000") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_anonymous_model(client: MultiPartClient):
+    await client.form_data.anonymous_model({"profileImage": open(str(JPG), "rb")})
+
+
+@pytest.mark.asyncio
+async def test_basic(client: MultiPartClient):
+    await client.form_data.basic(
+        models.MultiPartRequest(
+            id="123",
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_binary_array_parts(client: MultiPartClient):
+    await client.form_data.binary_array_parts(
+        models.BinaryArrayPartsRequest(
+            id="123",
+            pictures=[
+                open(str(PNG), "rb"),
+                open(str(PNG), "rb"),
+            ],
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_check_file_name_and_content_type(client: MultiPartClient):
+    await client.form_data.check_file_name_and_content_type(
+        models.MultiPartRequest(
+            id="123",
+            profile_image=("hello.jpg", open(str(JPG), "rb"), "image/jpg"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_complex(client: MultiPartClient):
+    await client.form_data.file_array_and_basic(
+        models.ComplexPartsRequest(
+            id="123",
+            address=models.Address(city="X"),
+            pictures=[
+                open(str(PNG), "rb"),
+                open(str(PNG), "rb"),
+            ],
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_json_part(client: MultiPartClient):
+    await client.form_data.json_part(
+        models.JsonPartRequest(
+            address=models.Address(city="X"),
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_multi_binary_parts(client: MultiPartClient):
+    await client.form_data.multi_binary_parts(
+        models.MultiBinaryPartsRequest(
+            profile_image=open(str(JPG), "rb"),
+            picture=open(str(PNG), "rb"),
+        )
+    )
+    await client.form_data.multi_binary_parts(
+        models.MultiBinaryPartsRequest(
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_file_with_http_part_specific_content_type(client: MultiPartClient):
+    await client.form_data.http_parts.content_type.image_jpeg_content_type(
+        models.FileWithHttpPartSpecificContentTypeRequest(
+            profile_image=("hello.jpg", open(str(JPG), "rb"), "image/jpg"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_file_with_http_part_required_content_type(client: MultiPartClient):
+    await client.form_data.http_parts.content_type.required_content_type(
+        models.FileWithHttpPartRequiredContentTypeRequest(
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_file_with_http_part_optional_content_type(client: MultiPartClient):
+    # call twice: one with content type, one without
+    await client.form_data.http_parts.content_type.optional_content_type(
+        models.FileWithHttpPartOptionalContentTypeRequest(
+            profile_image=("hello.jpg", open(str(JPG), "rb").read()),
+        )
+    )
+    await client.form_data.http_parts.content_type.optional_content_type(
+        models.FileWithHttpPartOptionalContentTypeRequest(
+            profile_image=("hello.jpg", open(str(JPG), "rb").read(), "application/octet-stream"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_complex_with_http_part(client: MultiPartClient):
+    await client.form_data.http_parts.json_array_and_file_array(
+        models.ComplexHttpPartsModelRequest(
+            id="123",
+            previous_addresses=[
+                models.Address(city="Y"),
+                models.Address(city="Z"),
+            ],
+            address=models.Address(city="X"),
+            pictures=[
+                open(str(PNG), "rb"),
+                open(str(PNG), "rb"),
+            ],
+            profile_image=open(str(JPG), "rb"),
+        )
+    )
+
+
+@pytest.mark.asyncio
+async def test_http_parts_non_string_float(client: MultiPartClient):
+    await client.form_data.http_parts.non_string.float(models.FloatRequest(temperature=0.5))

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

@@ -0,0 +1,19 @@
+# -------------------------------------------------------------------------
+# 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 payload.pageable.aio import PageableClient
+
+
+@pytest.fixture
+async def client():
+    async with PageableClient(endpoint="http://localhost:3000") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_list(client: PageableClient):
+    result = [p async for p in client.list(maxpagesize=3)]
+    assert len(result) == 4

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

@@ -0,0 +1,103 @@
+# -------------------------------------------------------------------------
+# 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 payload.xml.aio import XmlClient
+from payload.xml.models import (
+    SimpleModel,
+    ModelWithSimpleArrays,
+    ModelWithArrayOfModel,
+    ModelWithAttributes,
+    ModelWithUnwrappedArray,
+    ModelWithRenamedFields,
+    ModelWithEmptyArray,
+    ModelWithText,
+    ModelWithDictionary,
+    ModelWithEncodedNames,
+)
+
+
+@pytest.fixture
+async def client():
+    async with XmlClient(endpoint="http://localhost:3000") as client:
+        yield client
+
+
+@pytest.mark.asyncio
+async def test_simple_model(client: XmlClient):
+    model = SimpleModel(name="foo", age=123)
+    assert await client.simple_model_value.get() == model
+    await client.simple_model_value.put(model)
+
+
+@pytest.mark.asyncio
+async def test_model_with_simple_arrays(client: XmlClient):
+    model = ModelWithSimpleArrays(colors=["red", "green", "blue"], counts=[1, 2])
+    assert await client.model_with_simple_arrays_value.get() == model
+    await client.model_with_simple_arrays_value.put(model)
+
+
+@pytest.mark.asyncio
+async def test_model_with_array_of_model(client: XmlClient):
+    model = ModelWithArrayOfModel(
+        items_property=[
+            SimpleModel(name="foo", age=123),
+            SimpleModel(name="bar", age=456),
+        ]
+    )
+    assert await client.model_with_array_of_model_value.get() == model
+    await client.model_with_array_of_model_value.put(model)
+
+
+@pytest.mark.asyncio
+async def test_model_with_attributes(client: XmlClient):
+    model = ModelWithAttributes(id1=123, id2="foo", enabled=True)
+    assert await client.model_with_attributes_value.get() == model
+    await client.model_with_attributes_value.put(model)
+
+
+@pytest.mark.asyncio
+async def test_model_with_unwrapped_array(client: XmlClient):
+    model = ModelWithUnwrappedArray(colors=["red", "green", "blue"], counts=[1, 2])
+    assert await client.model_with_unwrapped_array_value.get() == model
+    await client.model_with_unwrapped_array_value.put(model)
+
+
+@pytest.mark.asyncio
+async def test_model_with_renamed_fields(client: XmlClient):
+    model = ModelWithRenamedFields(
+        input_data=SimpleModel(name="foo", age=123),
+        output_data=SimpleModel(name="bar", age=456),
+    )
+    assert await client.model_with_renamed_fields_value.get() == model
+    await client.model_with_renamed_fields_value.put(model)
+
+
+@pytest.mark.asyncio
+async def test_model_with_empty_array(client: XmlClient):
+    model = ModelWithEmptyArray(items_property=[])
+    assert await client.model_with_empty_array_value.get() == model
+    await client.model_with_empty_array_value.put(model)
+
+
+@pytest.mark.asyncio
+async def test_model_with_text(client: XmlClient):
+    model = ModelWithText(language="foo", content="\n  This is some text.\n")
+    assert await client.model_with_text_value.get() == model
+    await client.model_with_text_value.put(model)
+
+
+@pytest.mark.asyncio
+async def test_model_with_dictionary(client: XmlClient):
+    model = ModelWithDictionary(metadata={"Color": "blue", "Count": "123", "Enabled": "false"})
+    assert await client.model_with_dictionary_value.get() == model
+    await client.model_with_dictionary_value.put(model)
+
+
+@pytest.mark.asyncio
+async def test_model_with_encoded_names(client: XmlClient):
+    model = ModelWithEncodedNames(model_data=SimpleModel(name="foo", age=123), colors=["red", "green", "blue"])
+    assert await client.model_with_encoded_names_value.get() == model
+    await client.model_with_encoded_names_value.put(model)

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

@@ -0,0 +1,128 @@
+# -------------------------------------------------------------------------
+# 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 resiliency.srv.driven1.aio import ResiliencyServiceDrivenClient as V1Client
+from resiliency.srv.driven2.aio import ResiliencyServiceDrivenClient as V2Client
+
+
+def get_v1_client(service_deployment_version: str, api_version: str = "v1") -> V1Client:
+    return V1Client(
+        endpoint="http://localhost:3000",
+        service_deployment_version=service_deployment_version,
+        api_version=api_version,
+    )
+
+
+def get_v2_client(service_deployment_version: str, api_version: str = "v2") -> V2Client:
+    return V2Client(
+        endpoint="http://localhost:3000",
+        service_deployment_version=service_deployment_version,
+        api_version=api_version,
+    )
+
+
+@pytest.mark.asyncio
+async def test_add_optional_param_from_none():
+    # old client to old service with api version v1
+    async with V1Client(endpoint="http://localhost:3000", service_deployment_version="v1") as client:
+        await client.from_none()
+
+    # old client to new service with api version v1
+    async with V1Client(endpoint="http://localhost:3000", service_deployment_version="v2") as client:
+        await client.from_none()
+
+    # new client to new service with api version v1
+    async with V2Client(
+        endpoint="http://localhost:3000",
+        service_deployment_version="v2",
+        api_version="v1",
+    ) as client:
+        await client.from_none()
+
+    # new client to new service with api version v2
+    async with V2Client(endpoint="http://localhost:3000", service_deployment_version="v2") as client:
+        await client.from_none(new_parameter="new")
+
+
+@pytest.mark.asyncio
+async def test_add_optional_param_from_one_required():
+    # old client to old service with api version v1
+    async with V1Client(endpoint="http://localhost:3000", service_deployment_version="v1") as client:
+        await client.from_one_required(parameter="required")
+
+    # old client to new service with api version v1
+    async with V1Client(endpoint="http://localhost:3000", service_deployment_version="v2") as client:
+        await client.from_one_required(parameter="required")
+
+    # new client to new service with api version v1
+    async with V2Client(
+        endpoint="http://localhost:3000",
+        service_deployment_version="v2",
+        api_version="v1",
+    ) as client:
+        await client.from_one_required(parameter="required")
+
+    # new client to new service with api version v2
+    async with V2Client(endpoint="http://localhost:3000", service_deployment_version="v2") as client:
+        await client.from_one_required(parameter="required", new_parameter="new")
+
+
+@pytest.mark.asyncio
+async def test_add_optional_param_from_one_optional():
+    # old client to old service with api version v1
+    async with V1Client(endpoint="http://localhost:3000", service_deployment_version="v1") as client:
+        await client.from_one_optional(parameter="optional")
+
+    # old client to new service with api version v1
+    async with V1Client(endpoint="http://localhost:3000", service_deployment_version="v2") as client:
+        await client.from_one_optional(parameter="optional")
+
+    # new client to new service with api version v1
+    async with V2Client(
+        endpoint="http://localhost:3000",
+        service_deployment_version="v2",
+        api_version="v1",
+    ) as client:
+        await client.from_one_optional(parameter="optional")
+
+    # new client to new service with api version v2
+    async with V2Client(endpoint="http://localhost:3000", service_deployment_version="v2") as client:
+        await client.from_one_optional(parameter="optional", new_parameter="new")
+
+
+@pytest.mark.asyncio
+async def test_break_the_glass(core_library):
+    request = core_library.rest.HttpRequest(method="DELETE", url="/add-operation")
+    async with V1Client(
+        endpoint="http://localhost:3000",
+        service_deployment_version="v2",
+        api_version="v2",
+    ) as client:
+        response = await client.send_request(request)
+        response.raise_for_status()
+
+
+@pytest.mark.asyncio
+async def test_add_operation():
+    async with V2Client(endpoint="http://localhost:3000", service_deployment_version="v2") as client:
+        await client.add_operation()
+
+
+@pytest.mark.parametrize(
+    "func_name, params",
+    [
+        ("from_none", {"new_parameter": "new"}),
+        ("from_one_optional", {"parameter": "optional", "new_parameter": "new"}),
+        ("from_one_required", {"parameter": "required", "new_parameter": "new"}),
+        ("add_operation", {}),
+    ],
+)
+@pytest.mark.asyncio
+async def test_new_client_with_old_apiversion_call_new_parameter(func_name, params):
+    client = get_v2_client(service_deployment_version="v2", api_version="v1")
+    with pytest.raises(ValueError) as ex:
+        await getattr(client, func_name)(**params)
+    assert "is not available in API version" in str(ex.value)