@typespec/http-client-python 0.28.2 → 0.28.3

package/generator/test/generic_mock_api_tests/test_typetest_property_additionalproperties.py

@@ -1,314 +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 AdditionalPropertiesClient, models
-
-
-@pytest.fixture
-def client():
-    with AdditionalPropertiesClient() as client:
-        yield client
-
-
-def test_extends_different_spread_float(client: AdditionalPropertiesClient):
-    body = models.DifferentSpreadFloatDerived({"name": "abc", "prop": 43.125, "derivedProp": 43.125})
-    assert client.extends_different_spread_float.get() == body
-    client.extends_different_spread_float.put(body)
-
-
-def test_extends_different_spread_model(client: AdditionalPropertiesClient):
-    body = models.DifferentSpreadModelDerived(
-        {"knownProp": "abc", "prop": {"state": "ok"}, "derivedProp": {"state": "ok"}}
-    )
-    assert client.extends_different_spread_model.get() == body
-    client.extends_different_spread_model.put(body)
-
-
-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 client.extends_different_spread_model_array.get() == body
-    client.extends_different_spread_model_array.put(body)
-
-
-def test_extends_different_spread_string(client: AdditionalPropertiesClient):
-    body = models.DifferentSpreadStringDerived({"id": 43.125, "prop": "abc", "derivedProp": "abc"})
-    assert client.extends_different_spread_string.get() == body
-    client.extends_different_spread_string.put(body)
-
-
-def test_extends_float(client: AdditionalPropertiesClient):
-    body = models.ExtendsFloatAdditionalProperties({"id": 43.125, "prop": 43.125})
-    assert client.extends_float.get() == body
-    client.extends_float.put(body)
-
-
-def test_extends_model(client: AdditionalPropertiesClient):
-    body = models.ExtendsModelAdditionalProperties({"knownProp": {"state": "ok"}, "prop": {"state": "ok"}})
-    assert client.extends_model.get() == body
-    client.extends_model.put(body)
-
-
-def test_extends_model_array(client: AdditionalPropertiesClient):
-    body = models.ExtendsModelArrayAdditionalProperties(
-        {
-            "knownProp": [{"state": "ok"}, {"state": "ok"}],
-            "prop": [{"state": "ok"}, {"state": "ok"}],
-        }
-    )
-    assert client.extends_model_array.get() == body
-    client.extends_model_array.put(body)
-
-
-def test_extends_string(client: AdditionalPropertiesClient):
-    body = models.ExtendsStringAdditionalProperties({"name": "ExtendsStringAdditionalProperties", "prop": "abc"})
-    assert client.extends_string.get() == body
-    client.extends_string.put(body)
-
-
-def test_extends_unknown(client: AdditionalPropertiesClient):
-    body = models.ExtendsUnknownAdditionalProperties(
-        {
-            "name": "ExtendsUnknownAdditionalProperties",
-            "prop1": 32,
-            "prop2": True,
-            "prop3": "abc",
-        }
-    )
-    assert client.extends_unknown.get() == body
-    client.extends_unknown.put(body)
-
-
-def test_extends_unknown_derived(client: AdditionalPropertiesClient):
-    body = models.ExtendsUnknownAdditionalPropertiesDerived(
-        {
-            "name": "ExtendsUnknownAdditionalProperties",
-            "index": 314,
-            "age": 2.71875,
-            "prop1": 32,
-            "prop2": True,
-            "prop3": "abc",
-        }
-    )
-    assert client.extends_unknown_derived.get() == body
-    client.extends_unknown_derived.put(body)
-
-
-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 client.extends_unknown_discriminated.get() == body
-    client.extends_unknown_discriminated.put(body)
-
-
-def test_is_float(client: AdditionalPropertiesClient):
-    body = models.IsFloatAdditionalProperties({"id": 43.125, "prop": 43.125})
-    assert client.is_float.get() == body
-    client.is_float.put(body)
-
-
-def test_is_model(client: AdditionalPropertiesClient):
-    body = models.IsModelAdditionalProperties({"knownProp": {"state": "ok"}, "prop": {"state": "ok"}})
-    assert client.is_model.get() == body
-    client.is_model.put(body)
-
-
-def test_is_model_array(client: AdditionalPropertiesClient):
-    body = models.IsModelArrayAdditionalProperties(
-        {
-            "knownProp": [{"state": "ok"}, {"state": "ok"}],
-            "prop": [{"state": "ok"}, {"state": "ok"}],
-        }
-    )
-    assert client.is_model_array.get() == body
-    client.is_model_array.put(body)
-
-
-def test_is_string(client: AdditionalPropertiesClient):
-    body = models.IsStringAdditionalProperties({"name": "IsStringAdditionalProperties", "prop": "abc"})
-    assert client.is_string.get() == body
-    client.is_string.put(body)
-
-
-def test_is_unknown(client: AdditionalPropertiesClient):
-    body = models.IsUnknownAdditionalProperties(
-        {
-            "name": "IsUnknownAdditionalProperties",
-            "prop1": 32,
-            "prop2": True,
-            "prop3": "abc",
-        }
-    )
-    assert client.is_unknown.get() == body
-    client.is_unknown.put(body)
-
-
-def test_is_unknown_derived(client: AdditionalPropertiesClient):
-    body = models.IsUnknownAdditionalPropertiesDerived(
-        {
-            "name": "IsUnknownAdditionalProperties",
-            "index": 314,
-            "age": 2.71875,
-            "prop1": 32,
-            "prop2": True,
-            "prop3": "abc",
-        }
-    )
-    assert client.is_unknown_derived.get() == body
-    client.is_unknown_derived.put(body)
-
-
-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 client.is_unknown_discriminated.get() == body
-    client.is_unknown_discriminated.put(body)
-
-
-def test_multiple_spread(client: AdditionalPropertiesClient):
-    body = {"flag": True, "prop1": "abc", "prop2": 43.125}
-    assert client.multiple_spread.get() == body
-    client.multiple_spread.put(body)
-
-
-def test_spread_different_float(client: AdditionalPropertiesClient):
-    body = {"name": "abc", "prop": 43.125}
-    assert client.spread_different_float.get() == body
-    client.spread_different_float.put(body)
-
-
-def test_spread_different_model(client: AdditionalPropertiesClient):
-    body = {"knownProp": "abc", "prop": {"state": "ok"}}
-    assert client.spread_different_model.get() == body
-    client.spread_different_model.put(body)
-
-
-def test_spread_different_model_array(client: AdditionalPropertiesClient):
-    body = {"knownProp": "abc", "prop": [{"state": "ok"}, {"state": "ok"}]}
-    assert client.spread_different_model_array.get() == body
-    client.spread_different_model_array.put(body)
-
-
-def test_spread_different_string(client: AdditionalPropertiesClient):
-    body = {"id": 43.125, "prop": "abc"}
-    assert client.spread_different_string.get() == body
-    client.spread_different_string.put(body)
-
-
-def test_spread_model(client: AdditionalPropertiesClient):
-    body = {"knownProp": {"state": "ok"}, "prop": {"state": "ok"}}
-    assert client.spread_model.get() == body
-    client.spread_model.put(body)
-
-
-def test_spread_model_array(client: AdditionalPropertiesClient):
-    body = {
-        "knownProp": [{"state": "ok"}, {"state": "ok"}],
-        "prop": [{"state": "ok"}, {"state": "ok"}],
-    }
-    assert client.spread_model_array.get() == body
-    client.spread_model_array.put(body)
-
-
-@pytest.mark.skip(reason="https://github.com/microsoft/typespec/pull/6425")
-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 client.spread_record_discriminated_union.get() == body
-    client.spread_record_discriminated_union.put(body)
-
-
-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 client.spread_record_non_discriminated_union.get() == body
-    client.spread_record_non_discriminated_union.put(body)
-
-
-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 client.spread_record_non_discriminated_union2.get() == body
-    client.spread_record_non_discriminated_union2.put(body)
-
-
-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 client.spread_record_non_discriminated_union3.get() == body
-    client.spread_record_non_discriminated_union3.put(body)
-
-
-def test_spread_record_union(client: AdditionalPropertiesClient):
-    body = {"flag": True, "prop1": "abc", "prop2": 43.125}
-    assert client.spread_record_union.get() == body
-    client.spread_record_union.put(body)
-
-
-def test_spread_string(client: AdditionalPropertiesClient):
-    body = {"name": "SpreadSpringRecord", "prop": "abc"}
-    assert client.spread_string.get() == body
-    client.spread_string.put(body)
-
-
-def test_spread_float(client: AdditionalPropertiesClient):
-    body = {"id": 43.125, "prop": 43.125}
-    assert client.spread_float.get() == body
-    client.spread_float.put(body)

package/generator/test/generic_mock_api_tests/test_typetest_property_nullable.py

@@ -1,102 +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 NullableClient, models
-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
-def client():
-    with NullableClient() as client:
-        yield client
-
-
-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 client.bytes.get_non_null() == non_null_model
-    assert client.bytes.get_null()["nullableProperty"] is None
-    client.bytes.patch_non_null(body=non_null_model)
-    client.bytes.patch_null(body=non_model)
-
-
-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 client.collections_byte.get_non_null() == non_null_model
-    assert client.collections_byte.get_null()["nullableProperty"] is None
-    client.collections_byte.patch_non_null(body=non_null_model)
-    client.collections_byte.patch_null(body=non_model)
-
-
-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 client.collections_model.get_non_null() == non_null_model
-    assert client.collections_model.get_null()["nullableProperty"] is None
-    client.collections_model.patch_non_null(body=non_null_model)
-    client.collections_model.patch_null(body=non_model)
-
-
-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 client.collections_string.get_non_null() == non_null_model
-    assert client.collections_string.get_null()["nullableProperty"] is None
-    client.collections_string.patch_non_null(body=non_null_model)
-    client.collections_string.patch_null(body=non_model)
-
-
-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 client.datetime.get_non_null() == non_null_model
-    assert client.datetime.get_null()["nullableProperty"] is None
-    client.datetime.patch_non_null(body=non_null_model)
-    client.datetime.patch_null(body=non_model)
-
-
-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 client.duration.get_non_null() == non_null_model
-    assert client.duration.get_null()["nullableProperty"] is None
-    client.duration.patch_non_null(body=non_null_model)
-    client.duration.patch_null(body=non_model)
-
-
-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 client.string.get_non_null() == non_null_model
-    assert client.string.get_null()["nullableProperty"] is None
-    client.string.patch_non_null(body=non_null_model)
-    client.string.patch_null(body=non_model)

package/generator/test/generic_mock_api_tests/test_typetest_property_optional.py

@@ -1,174 +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.
-# --------------------------------------------------------------------------
-from typing import Any
-import pytest
-from typetest.property.optional import OptionalClient, models
-
-
-@pytest.fixture
-def client():
-    with OptionalClient() as client:
-        yield client
-
-
-def test_boolean_literal(client):
-    body = models.BooleanLiteralProperty(property=True)
-    assert client.boolean_literal.get_all() == body
-    assert client.boolean_literal.get_default() == models.BooleanLiteralProperty()
-    client.boolean_literal.put_all(body)
-    client.boolean_literal.put_default(models.BooleanLiteralProperty())
-
-
-def test_bytes(client):
-    body = models.BytesProperty(property="aGVsbG8sIHdvcmxkIQ==")
-    assert client.bytes.get_all() == body
-    assert client.bytes.get_default() == models.BytesProperty()
-    client.bytes.put_all(body)
-    client.bytes.put_default(models.BytesProperty())
-
-
-def test_collections_byte(client):
-    body = models.CollectionsByteProperty(property=["aGVsbG8sIHdvcmxkIQ==", "aGVsbG8sIHdvcmxkIQ=="])
-    assert client.collections_byte.get_all() == body
-    assert client.collections_byte.get_default() == models.CollectionsByteProperty()
-    client.collections_byte.put_all(body)
-    client.collections_byte.put_default(models.CollectionsByteProperty())
-
-
-def test_collections_model(client):
-    body = models.CollectionsModelProperty(
-        property=[
-            models.StringProperty(property="hello"),
-            models.StringProperty(property="world"),
-        ]
-    )
-    assert client.collections_model.get_all() == body
-    assert client.collections_model.get_default() == models.CollectionsModelProperty()
-    client.collections_model.put_all(body)
-    client.collections_model.put_default(models.CollectionsModelProperty())
-
-
-def test_datetime(client):
-    body = models.DatetimeProperty(property="2022-08-26T18:38:00Z")
-    assert client.datetime.get_all() == body
-    assert client.datetime.get_default() == models.DatetimeProperty()
-    client.datetime.put_all(body)
-    client.datetime.put_default(models.DatetimeProperty())
-
-
-def test_duration(client):
-    body = models.DurationProperty(property="P123DT22H14M12.011S")
-    assert client.duration.get_all() == body
-    assert client.duration.get_default() == models.DurationProperty()
-    client.duration.put_all(body)
-    client.duration.put_default(models.DurationProperty())
-
-
-def test_float_literal(client):
-    body = models.FloatLiteralProperty(property=1.25)
-    assert client.float_literal.get_all() == body
-    assert client.float_literal.get_default() == models.FloatLiteralProperty()
-    client.float_literal.put_all(body)
-    client.float_literal.put_default(models.FloatLiteralProperty())
-
-
-def test_int_literal(client):
-    body = models.IntLiteralProperty(property=1)
-    assert client.int_literal.get_all() == body
-    assert client.int_literal.get_default() == models.IntLiteralProperty()
-    client.int_literal.put_all(body)
-    client.int_literal.put_default(models.IntLiteralProperty())
-
-
-def test_plaindate_get_all(client):
-    body = models.PlainDateProperty(property="2022-12-12")
-    assert client.plain_date.get_all() == body
-
-
-def test_plaindate_get_default(client):
-    assert client.plain_date.get_default() == models.PlainDateProperty()
-
-
-def test_plaindate_put_all(client):
-    body = models.PlainDateProperty(property="2022-12-12")
-    client.plain_date.put_all(body)
-
-
-def test_plaindate_put_default(client):
-    client.plain_date.put_default(models.PlainDateProperty())
-
-
-def test_plaintime_get_all(client):
-    body = models.PlainTimeProperty(property="13:06:12")
-    assert client.plain_time.get_all() == body
-
-
-def test_plaintime_get_default(client):
-    assert client.plain_time.get_default() == models.PlainTimeProperty()
-
-
-def test_plaintime_put_all(client):
-    body = models.PlainTimeProperty(property="13:06:12")
-    client.plain_time.put_all(body)
-
-
-def test_plaintime_put_default(client):
-    client.plain_time.put_default(models.PlainTimeProperty())
-
-
-def test_required_and_optional(client):
-    all_body = {
-        "optionalProperty": "hello",
-        "requiredProperty": 42,
-    }
-    required_only_body = {
-        "requiredProperty": 42,
-    }
-    assert client.required_and_optional.get_all() == all_body
-    assert client.required_and_optional.get_required_only() == required_only_body
-    client.required_and_optional.put_all(all_body)
-    client.required_and_optional.put_required_only(required_only_body)
-
-
-def test_string(client):
-    body = models.StringProperty(property="hello")
-    assert client.string.get_all() == body
-    assert client.string.get_default() == models.StringProperty()
-    client.string.put_all(body)
-    client.string.put_default(models.StringProperty())
-
-
-def test_string_literal(client):
-    body = models.StringLiteralProperty(property="hello")
-    assert client.string_literal.get_all() == body
-    assert client.string_literal.get_default() == models.StringLiteralProperty()
-    client.string_literal.put_all(body)
-    client.string_literal.put_default(models.StringLiteralProperty())
-
-
-def test_union_float_literal(client):
-    body = models.UnionFloatLiteralProperty(property=2.375)
-    assert client.union_float_literal.get_all() == body
-    assert client.union_float_literal.get_default() == models.UnionFloatLiteralProperty()
-    client.union_float_literal.put_all(body)
-    client.union_float_literal.put_default(models.UnionFloatLiteralProperty())
-
-
-def test_union_int_literal(client):
-    body = models.UnionIntLiteralProperty(property=2)
-    assert client.union_int_literal.get_all() == body
-    assert client.union_int_literal.get_default() == models.UnionIntLiteralProperty()
-    client.union_int_literal.put_all(body)
-    client.union_int_literal.put_default(models.UnionIntLiteralProperty())
-
-
-def test_union_string_literal(client):
-    body = models.UnionStringLiteralProperty(property="world")
-    assert client.union_string_literal.get_all() == body
-    assert client.union_string_literal.get_default() == models.UnionStringLiteralProperty()
-    client.union_string_literal.put_all(body)
-    client.union_string_literal.put_default(models.UnionStringLiteralProperty())