diff --git a/.stats.yml b/.stats.yml index 374bd14fc90..f104a2802ba 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,2 +1,2 @@ -configured_endpoints: 1408 +configured_endpoints: 1407 openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/cloudflare%2Fcloudflare-e1b0a84e75d7d2eb973ab4f14ecab9f77bd39c49ebc14fdd54066e72aa43a5be.yml diff --git a/api.md b/api.md index 44c5e2d0fdc..847c6166c78 100644 --- a/api.md +++ b/api.md @@ -1856,24 +1856,12 @@ from cloudflare.types.pagerules import ( Methods: -- client.pagerules.create(\*, zone_id, \*\*params) -> Optional -- client.pagerules.update(pagerule_id, \*, zone_id, \*\*params) -> Optional -- client.pagerules.list(\*, zone_id, \*\*params) -> Optional -- client.pagerules.delete(pagerule_id, \*, zone_id) -> Optional -- client.pagerules.edit(pagerule_id, \*, zone_id, \*\*params) -> Optional -- client.pagerules.get(pagerule_id, \*, zone_id) -> Optional - -## Settings - -Types: - -```python -from cloudflare.types.pagerules import SettingListResponse -``` - -Methods: - -- client.pagerules.settings.list(\*, zone_id) -> Optional +- client.pagerules.create(\*, zone_id, \*\*params) -> Optional +- client.pagerules.update(pagerule_id, \*, zone_id, \*\*params) -> Optional +- client.pagerules.list(\*, zone_id, \*\*params) -> Optional +- client.pagerules.delete(pagerule_id, \*, zone_id) -> Optional +- client.pagerules.edit(pagerule_id, \*, zone_id, \*\*params) -> Optional +- client.pagerules.get(pagerule_id, \*, zone_id) -> Optional # RateLimits diff --git a/src/cloudflare/resources/pagerules/pagerules.py b/src/cloudflare/resources/pagerules.py similarity index 78% rename from src/cloudflare/resources/pagerules/pagerules.py rename to src/cloudflare/resources/pagerules.py index 7bfa3204cfe..3297f84978a 100644 --- a/src/cloudflare/resources/pagerules/pagerules.py +++ b/src/cloudflare/resources/pagerules.py @@ -2,54 +2,36 @@ from __future__ import annotations -import typing_extensions from typing import Type, Iterable, Optional, cast from typing_extensions import Literal import httpx -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._utils import ( +from .._types import NOT_GIVEN, Body, Query, Headers, NotGiven +from .._utils import ( maybe_transform, async_maybe_transform, ) -from .settings import ( - SettingsResource, - AsyncSettingsResource, - SettingsResourceWithRawResponse, - AsyncSettingsResourceWithRawResponse, - SettingsResourceWithStreamingResponse, - AsyncSettingsResourceWithStreamingResponse, -) -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( +from .._compat import cached_property +from .._resource import SyncAPIResource, AsyncAPIResource +from .._response import ( to_raw_response_wrapper, to_streamed_response_wrapper, async_to_raw_response_wrapper, async_to_streamed_response_wrapper, ) -from ..._wrappers import ResultWrapper -from ..._base_client import make_request_options -from ...types.pagerules import ( - pagerule_edit_params, - pagerule_list_params, - pagerule_create_params, - pagerule_update_params, -) -from ...types.pagerules.page_rule import PageRule -from ...types.pagerules.target_param import TargetParam -from ...types.pagerules.pagerule_list_response import PageruleListResponse -from ...types.pagerules.pagerule_delete_response import PageruleDeleteResponse +from .._wrappers import ResultWrapper +from .._base_client import make_request_options +from ..types.pagerules import pagerule_edit_params, pagerule_list_params, pagerule_create_params, pagerule_update_params +from ..types.pagerules.page_rule import PageRule +from ..types.pagerules.target_param import TargetParam +from ..types.pagerules.pagerule_list_response import PageruleListResponse +from ..types.pagerules.pagerule_delete_response import PageruleDeleteResponse __all__ = ["PagerulesResource", "AsyncPagerulesResource"] class PagerulesResource(SyncAPIResource): - @cached_property - def settings(self) -> SettingsResource: - return SettingsResource(self._client) - @cached_property def with_raw_response(self) -> PagerulesResourceWithRawResponse: """ @@ -69,9 +51,6 @@ def with_streaming_response(self) -> PagerulesResourceWithStreamingResponse: """ return PagerulesResourceWithStreamingResponse(self) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) def create( self, *, @@ -137,9 +116,6 @@ def create( cast_to=cast(Type[Optional[PageRule]], ResultWrapper[PageRule]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) def update( self, pagerule_id: str, @@ -212,9 +188,6 @@ def update( cast_to=cast(Type[Optional[PageRule]], ResultWrapper[PageRule]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) def list( self, *, @@ -276,9 +249,6 @@ def list( cast_to=cast(Type[Optional[PageruleListResponse]], ResultWrapper[PageruleListResponse]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) def delete( self, pagerule_id: str, @@ -323,9 +293,6 @@ def delete( cast_to=cast(Type[Optional[PageruleDeleteResponse]], ResultWrapper[PageruleDeleteResponse]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) def edit( self, pagerule_id: str, @@ -396,9 +363,6 @@ def edit( cast_to=cast(Type[Optional[PageRule]], ResultWrapper[PageRule]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) def get( self, pagerule_id: str, @@ -445,10 +409,6 @@ def get( class AsyncPagerulesResource(AsyncAPIResource): - @cached_property - def settings(self) -> AsyncSettingsResource: - return AsyncSettingsResource(self._client) - @cached_property def with_raw_response(self) -> AsyncPagerulesResourceWithRawResponse: """ @@ -468,9 +428,6 @@ def with_streaming_response(self) -> AsyncPagerulesResourceWithStreamingResponse """ return AsyncPagerulesResourceWithStreamingResponse(self) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) async def create( self, *, @@ -536,9 +493,6 @@ async def create( cast_to=cast(Type[Optional[PageRule]], ResultWrapper[PageRule]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) async def update( self, pagerule_id: str, @@ -611,9 +565,6 @@ async def update( cast_to=cast(Type[Optional[PageRule]], ResultWrapper[PageRule]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) async def list( self, *, @@ -675,9 +626,6 @@ async def list( cast_to=cast(Type[Optional[PageruleListResponse]], ResultWrapper[PageruleListResponse]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) async def delete( self, pagerule_id: str, @@ -722,9 +670,6 @@ async def delete( cast_to=cast(Type[Optional[PageruleDeleteResponse]], ResultWrapper[PageruleDeleteResponse]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) async def edit( self, pagerule_id: str, @@ -795,9 +740,6 @@ async def edit( cast_to=cast(Type[Optional[PageRule]], ResultWrapper[PageRule]), ) - @typing_extensions.deprecated( - "The Page Rules API is deprecated in favour of the Ruleset Engine. See https://developers.cloudflare.com/fundamentals/api/reference/deprecations/#page-rules for full details." - ) async def get( self, pagerule_id: str, @@ -847,157 +789,93 @@ class PagerulesResourceWithRawResponse: def __init__(self, pagerules: PagerulesResource) -> None: self._pagerules = pagerules - self.create = ( # pyright: ignore[reportDeprecated] - to_raw_response_wrapper( - pagerules.create # pyright: ignore[reportDeprecated], - ) + self.create = to_raw_response_wrapper( + pagerules.create, ) - self.update = ( # pyright: ignore[reportDeprecated] - to_raw_response_wrapper( - pagerules.update # pyright: ignore[reportDeprecated], - ) + self.update = to_raw_response_wrapper( + pagerules.update, ) - self.list = ( # pyright: ignore[reportDeprecated] - to_raw_response_wrapper( - pagerules.list # pyright: ignore[reportDeprecated], - ) + self.list = to_raw_response_wrapper( + pagerules.list, ) - self.delete = ( # pyright: ignore[reportDeprecated] - to_raw_response_wrapper( - pagerules.delete # pyright: ignore[reportDeprecated], - ) + self.delete = to_raw_response_wrapper( + pagerules.delete, ) - self.edit = ( # pyright: ignore[reportDeprecated] - to_raw_response_wrapper( - pagerules.edit # pyright: ignore[reportDeprecated], - ) + self.edit = to_raw_response_wrapper( + pagerules.edit, ) - self.get = ( # pyright: ignore[reportDeprecated] - to_raw_response_wrapper( - pagerules.get # pyright: ignore[reportDeprecated], - ) + self.get = to_raw_response_wrapper( + pagerules.get, ) - @cached_property - def settings(self) -> SettingsResourceWithRawResponse: - return SettingsResourceWithRawResponse(self._pagerules.settings) - class AsyncPagerulesResourceWithRawResponse: def __init__(self, pagerules: AsyncPagerulesResource) -> None: self._pagerules = pagerules - self.create = ( # pyright: ignore[reportDeprecated] - async_to_raw_response_wrapper( - pagerules.create # pyright: ignore[reportDeprecated], - ) + self.create = async_to_raw_response_wrapper( + pagerules.create, ) - self.update = ( # pyright: ignore[reportDeprecated] - async_to_raw_response_wrapper( - pagerules.update # pyright: ignore[reportDeprecated], - ) + self.update = async_to_raw_response_wrapper( + pagerules.update, ) - self.list = ( # pyright: ignore[reportDeprecated] - async_to_raw_response_wrapper( - pagerules.list # pyright: ignore[reportDeprecated], - ) + self.list = async_to_raw_response_wrapper( + pagerules.list, ) - self.delete = ( # pyright: ignore[reportDeprecated] - async_to_raw_response_wrapper( - pagerules.delete # pyright: ignore[reportDeprecated], - ) + self.delete = async_to_raw_response_wrapper( + pagerules.delete, ) - self.edit = ( # pyright: ignore[reportDeprecated] - async_to_raw_response_wrapper( - pagerules.edit # pyright: ignore[reportDeprecated], - ) + self.edit = async_to_raw_response_wrapper( + pagerules.edit, ) - self.get = ( # pyright: ignore[reportDeprecated] - async_to_raw_response_wrapper( - pagerules.get # pyright: ignore[reportDeprecated], - ) + self.get = async_to_raw_response_wrapper( + pagerules.get, ) - @cached_property - def settings(self) -> AsyncSettingsResourceWithRawResponse: - return AsyncSettingsResourceWithRawResponse(self._pagerules.settings) - class PagerulesResourceWithStreamingResponse: def __init__(self, pagerules: PagerulesResource) -> None: self._pagerules = pagerules - self.create = ( # pyright: ignore[reportDeprecated] - to_streamed_response_wrapper( - pagerules.create # pyright: ignore[reportDeprecated], - ) + self.create = to_streamed_response_wrapper( + pagerules.create, ) - self.update = ( # pyright: ignore[reportDeprecated] - to_streamed_response_wrapper( - pagerules.update # pyright: ignore[reportDeprecated], - ) + self.update = to_streamed_response_wrapper( + pagerules.update, ) - self.list = ( # pyright: ignore[reportDeprecated] - to_streamed_response_wrapper( - pagerules.list # pyright: ignore[reportDeprecated], - ) + self.list = to_streamed_response_wrapper( + pagerules.list, ) - self.delete = ( # pyright: ignore[reportDeprecated] - to_streamed_response_wrapper( - pagerules.delete # pyright: ignore[reportDeprecated], - ) + self.delete = to_streamed_response_wrapper( + pagerules.delete, ) - self.edit = ( # pyright: ignore[reportDeprecated] - to_streamed_response_wrapper( - pagerules.edit # pyright: ignore[reportDeprecated], - ) + self.edit = to_streamed_response_wrapper( + pagerules.edit, ) - self.get = ( # pyright: ignore[reportDeprecated] - to_streamed_response_wrapper( - pagerules.get # pyright: ignore[reportDeprecated], - ) + self.get = to_streamed_response_wrapper( + pagerules.get, ) - @cached_property - def settings(self) -> SettingsResourceWithStreamingResponse: - return SettingsResourceWithStreamingResponse(self._pagerules.settings) - class AsyncPagerulesResourceWithStreamingResponse: def __init__(self, pagerules: AsyncPagerulesResource) -> None: self._pagerules = pagerules - self.create = ( # pyright: ignore[reportDeprecated] - async_to_streamed_response_wrapper( - pagerules.create # pyright: ignore[reportDeprecated], - ) + self.create = async_to_streamed_response_wrapper( + pagerules.create, ) - self.update = ( # pyright: ignore[reportDeprecated] - async_to_streamed_response_wrapper( - pagerules.update # pyright: ignore[reportDeprecated], - ) + self.update = async_to_streamed_response_wrapper( + pagerules.update, ) - self.list = ( # pyright: ignore[reportDeprecated] - async_to_streamed_response_wrapper( - pagerules.list # pyright: ignore[reportDeprecated], - ) + self.list = async_to_streamed_response_wrapper( + pagerules.list, ) - self.delete = ( # pyright: ignore[reportDeprecated] - async_to_streamed_response_wrapper( - pagerules.delete # pyright: ignore[reportDeprecated], - ) + self.delete = async_to_streamed_response_wrapper( + pagerules.delete, ) - self.edit = ( # pyright: ignore[reportDeprecated] - async_to_streamed_response_wrapper( - pagerules.edit # pyright: ignore[reportDeprecated], - ) + self.edit = async_to_streamed_response_wrapper( + pagerules.edit, ) - self.get = ( # pyright: ignore[reportDeprecated] - async_to_streamed_response_wrapper( - pagerules.get # pyright: ignore[reportDeprecated], - ) + self.get = async_to_streamed_response_wrapper( + pagerules.get, ) - - @cached_property - def settings(self) -> AsyncSettingsResourceWithStreamingResponse: - return AsyncSettingsResourceWithStreamingResponse(self._pagerules.settings) diff --git a/src/cloudflare/resources/pagerules/__init__.py b/src/cloudflare/resources/pagerules/__init__.py deleted file mode 100644 index d1c6434816b..00000000000 --- a/src/cloudflare/resources/pagerules/__init__.py +++ /dev/null @@ -1,33 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from .settings import ( - SettingsResource, - AsyncSettingsResource, - SettingsResourceWithRawResponse, - AsyncSettingsResourceWithRawResponse, - SettingsResourceWithStreamingResponse, - AsyncSettingsResourceWithStreamingResponse, -) -from .pagerules import ( - PagerulesResource, - AsyncPagerulesResource, - PagerulesResourceWithRawResponse, - AsyncPagerulesResourceWithRawResponse, - PagerulesResourceWithStreamingResponse, - AsyncPagerulesResourceWithStreamingResponse, -) - -__all__ = [ - "SettingsResource", - "AsyncSettingsResource", - "SettingsResourceWithRawResponse", - "AsyncSettingsResourceWithRawResponse", - "SettingsResourceWithStreamingResponse", - "AsyncSettingsResourceWithStreamingResponse", - "PagerulesResource", - "AsyncPagerulesResource", - "PagerulesResourceWithRawResponse", - "AsyncPagerulesResourceWithRawResponse", - "PagerulesResourceWithStreamingResponse", - "AsyncPagerulesResourceWithStreamingResponse", -] diff --git a/src/cloudflare/resources/pagerules/settings.py b/src/cloudflare/resources/pagerules/settings.py deleted file mode 100644 index bd598cff9db..00000000000 --- a/src/cloudflare/resources/pagerules/settings.py +++ /dev/null @@ -1,180 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -from typing import Type, Optional, cast - -import httpx - -from ..._types import NOT_GIVEN, Body, Query, Headers, NotGiven -from ..._compat import cached_property -from ..._resource import SyncAPIResource, AsyncAPIResource -from ..._response import ( - to_raw_response_wrapper, - to_streamed_response_wrapper, - async_to_raw_response_wrapper, - async_to_streamed_response_wrapper, -) -from ..._wrappers import ResultWrapper -from ..._base_client import make_request_options -from ...types.pagerules.setting_list_response import SettingListResponse - -__all__ = ["SettingsResource", "AsyncSettingsResource"] - - -class SettingsResource(SyncAPIResource): - @cached_property - def with_raw_response(self) -> SettingsResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return the - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers - """ - return SettingsResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> SettingsResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response - """ - return SettingsResourceWithStreamingResponse(self) - - def list( - self, - *, - zone_id: str, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[SettingListResponse]: - """ - Returns a list of settings (and their details) that Page Rules can apply to - matching requests. - - Args: - zone_id: Identifier - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not zone_id: - raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") - return self._get( - f"/zones/{zone_id}/pagerules/settings", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - post_parser=ResultWrapper[Optional[SettingListResponse]]._unwrapper, - ), - cast_to=cast(Type[Optional[SettingListResponse]], ResultWrapper[SettingListResponse]), - ) - - -class AsyncSettingsResource(AsyncAPIResource): - @cached_property - def with_raw_response(self) -> AsyncSettingsResourceWithRawResponse: - """ - This property can be used as a prefix for any HTTP method call to return the - the raw response object instead of the parsed content. - - For more information, see https://www.github.com/cloudflare/cloudflare-python#accessing-raw-response-data-eg-headers - """ - return AsyncSettingsResourceWithRawResponse(self) - - @cached_property - def with_streaming_response(self) -> AsyncSettingsResourceWithStreamingResponse: - """ - An alternative to `.with_raw_response` that doesn't eagerly read the response body. - - For more information, see https://www.github.com/cloudflare/cloudflare-python#with_streaming_response - """ - return AsyncSettingsResourceWithStreamingResponse(self) - - async def list( - self, - *, - zone_id: str, - # Use the following arguments if you need to pass additional parameters to the API that aren't available via kwargs. - # The extra values given here take precedence over values defined on the client or passed to this method. - extra_headers: Headers | None = None, - extra_query: Query | None = None, - extra_body: Body | None = None, - timeout: float | httpx.Timeout | None | NotGiven = NOT_GIVEN, - ) -> Optional[SettingListResponse]: - """ - Returns a list of settings (and their details) that Page Rules can apply to - matching requests. - - Args: - zone_id: Identifier - - extra_headers: Send extra headers - - extra_query: Add additional query parameters to the request - - extra_body: Add additional JSON properties to the request - - timeout: Override the client-level default timeout for this request, in seconds - """ - if not zone_id: - raise ValueError(f"Expected a non-empty value for `zone_id` but received {zone_id!r}") - return await self._get( - f"/zones/{zone_id}/pagerules/settings", - options=make_request_options( - extra_headers=extra_headers, - extra_query=extra_query, - extra_body=extra_body, - timeout=timeout, - post_parser=ResultWrapper[Optional[SettingListResponse]]._unwrapper, - ), - cast_to=cast(Type[Optional[SettingListResponse]], ResultWrapper[SettingListResponse]), - ) - - -class SettingsResourceWithRawResponse: - def __init__(self, settings: SettingsResource) -> None: - self._settings = settings - - self.list = to_raw_response_wrapper( - settings.list, - ) - - -class AsyncSettingsResourceWithRawResponse: - def __init__(self, settings: AsyncSettingsResource) -> None: - self._settings = settings - - self.list = async_to_raw_response_wrapper( - settings.list, - ) - - -class SettingsResourceWithStreamingResponse: - def __init__(self, settings: SettingsResource) -> None: - self._settings = settings - - self.list = to_streamed_response_wrapper( - settings.list, - ) - - -class AsyncSettingsResourceWithStreamingResponse: - def __init__(self, settings: AsyncSettingsResource) -> None: - self._settings = settings - - self.list = async_to_streamed_response_wrapper( - settings.list, - ) diff --git a/src/cloudflare/types/pagerules/__init__.py b/src/cloudflare/types/pagerules/__init__.py index 067b2828771..a023afa9b37 100644 --- a/src/cloudflare/types/pagerules/__init__.py +++ b/src/cloudflare/types/pagerules/__init__.py @@ -7,7 +7,6 @@ from .target_param import TargetParam as TargetParam from .pagerule_edit_params import PageruleEditParams as PageruleEditParams from .pagerule_list_params import PageruleListParams as PageruleListParams -from .setting_list_response import SettingListResponse as SettingListResponse from .pagerule_create_params import PageruleCreateParams as PageruleCreateParams from .pagerule_list_response import PageruleListResponse as PageruleListResponse from .pagerule_update_params import PageruleUpdateParams as PageruleUpdateParams diff --git a/src/cloudflare/types/pagerules/setting_list_response.py b/src/cloudflare/types/pagerules/setting_list_response.py deleted file mode 100644 index 69e8c454a09..00000000000 --- a/src/cloudflare/types/pagerules/setting_list_response.py +++ /dev/null @@ -1,8 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from typing import List -from typing_extensions import TypeAlias - -__all__ = ["SettingListResponse"] - -SettingListResponse: TypeAlias = List[object] diff --git a/tests/api_resources/pagerules/__init__.py b/tests/api_resources/pagerules/__init__.py deleted file mode 100644 index fd8019a9a1a..00000000000 --- a/tests/api_resources/pagerules/__init__.py +++ /dev/null @@ -1 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. diff --git a/tests/api_resources/pagerules/test_settings.py b/tests/api_resources/pagerules/test_settings.py deleted file mode 100644 index 06b7aa3a064..00000000000 --- a/tests/api_resources/pagerules/test_settings.py +++ /dev/null @@ -1,98 +0,0 @@ -# File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. - -from __future__ import annotations - -import os -from typing import Any, Optional, cast - -import pytest - -from cloudflare import Cloudflare, AsyncCloudflare -from tests.utils import assert_matches_type -from cloudflare.types.pagerules import SettingListResponse - -base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") - - -class TestSettings: - parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - - @parametrize - def test_method_list(self, client: Cloudflare) -> None: - setting = client.pagerules.settings.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - assert_matches_type(Optional[SettingListResponse], setting, path=["response"]) - - @parametrize - def test_raw_response_list(self, client: Cloudflare) -> None: - response = client.pagerules.settings.with_raw_response.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - setting = response.parse() - assert_matches_type(Optional[SettingListResponse], setting, path=["response"]) - - @parametrize - def test_streaming_response_list(self, client: Cloudflare) -> None: - with client.pagerules.settings.with_streaming_response.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - setting = response.parse() - assert_matches_type(Optional[SettingListResponse], setting, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @parametrize - def test_path_params_list(self, client: Cloudflare) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.settings.with_raw_response.list( - zone_id="", - ) - - -class TestAsyncSettings: - parametrize = pytest.mark.parametrize("async_client", [False, True], indirect=True, ids=["loose", "strict"]) - - @parametrize - async def test_method_list(self, async_client: AsyncCloudflare) -> None: - setting = await async_client.pagerules.settings.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - assert_matches_type(Optional[SettingListResponse], setting, path=["response"]) - - @parametrize - async def test_raw_response_list(self, async_client: AsyncCloudflare) -> None: - response = await async_client.pagerules.settings.with_raw_response.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - setting = await response.parse() - assert_matches_type(Optional[SettingListResponse], setting, path=["response"]) - - @parametrize - async def test_streaming_response_list(self, async_client: AsyncCloudflare) -> None: - async with async_client.pagerules.settings.with_streaming_response.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - setting = await response.parse() - assert_matches_type(Optional[SettingListResponse], setting, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @parametrize - async def test_path_params_list(self, async_client: AsyncCloudflare) -> None: - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.settings.with_raw_response.list( - zone_id="", - ) diff --git a/tests/api_resources/test_pagerules.py b/tests/api_resources/test_pagerules.py index 15c52b336a1..68a6822ba59 100644 --- a/tests/api_resources/test_pagerules.py +++ b/tests/api_resources/test_pagerules.py @@ -15,8 +15,6 @@ PageruleDeleteResponse, ) -# pyright: reportDeprecated=false - base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") @@ -25,65 +23,60 @@ class TestPagerules: @parametrize def test_method_create(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.create( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) - + pagerule = client.pagerules.create( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize def test_method_create_with_all_params(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.create( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[ - { - "id": "browser_check", - "value": "on", - } - ], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - priority=0, - status="active", - ) - + pagerule = client.pagerules.create( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[ + { + "id": "browser_check", + "value": "on", + } + ], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + priority=0, + status="active", + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize def test_raw_response_create(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = client.pagerules.with_raw_response.create( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) + response = client.pagerules.with_raw_response.create( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -92,52 +85,32 @@ def test_raw_response_create(self, client: Cloudflare) -> None: @parametrize def test_streaming_response_create(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with client.pagerules.with_streaming_response.create( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + with client.pagerules.with_streaming_response.create( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pagerule = response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_create(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.create( - zone_id="", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) - - @parametrize - def test_method_update(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.update( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.pagerules.with_raw_response.create( + zone_id="", actions=[{}], targets=[ { @@ -150,41 +123,101 @@ def test_method_update(self, client: Cloudflare) -> None: ], ) + @parametrize + def test_method_update(self, client: Cloudflare) -> None: + pagerule = client.pagerules.update( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize def test_method_update_with_all_params(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.update( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[ - { - "id": "browser_check", - "value": "on", - } - ], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - priority=0, - status="active", - ) - + pagerule = client.pagerules.update( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[ + { + "id": "browser_check", + "value": "on", + } + ], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + priority=0, + status="active", + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize def test_raw_response_update(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = client.pagerules.with_raw_response.update( + response = client.pagerules.with_raw_response.update( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + pagerule = response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + + @parametrize + def test_streaming_response_update(self, client: Cloudflare) -> None: + with client.pagerules.with_streaming_response.update( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pagerule = response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + def test_path_params_update(self, client: Cloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.pagerules.with_raw_response.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="", actions=[{}], targets=[ { @@ -197,16 +230,9 @@ def test_raw_response_update(self, client: Cloudflare) -> None: ], ) - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) - - @parametrize - def test_streaming_response_update(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with client.pagerules.with_streaming_response.update( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): + client.pagerules.with_raw_response.update( + pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], targets=[ @@ -218,78 +244,31 @@ def test_streaming_response_update(self, client: Cloudflare) -> None: "target": "url", } ], - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @parametrize - def test_path_params_update(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.update( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - client.pagerules.with_raw_response.update( - pagerule_id="", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) + ) @parametrize def test_method_list(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - + pagerule = client.pagerules.list( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) @parametrize def test_method_list_with_all_params(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - direction="asc", - match="any", - order="status", - status="active", - ) - + pagerule = client.pagerules.list( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + direction="asc", + match="any", + order="status", + status="active", + ) assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) @parametrize def test_raw_response_list(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = client.pagerules.with_raw_response.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + response = client.pagerules.with_raw_response.list( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -298,43 +277,38 @@ def test_raw_response_list(self, client: Cloudflare) -> None: @parametrize def test_streaming_response_list(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with client.pagerules.with_streaming_response.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" + with client.pagerules.with_streaming_response.list( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + pagerule = response.parse() + assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_list(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.list( - zone_id="", - ) + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.pagerules.with_raw_response.list( + zone_id="", + ) @parametrize def test_method_delete(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.delete( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - + pagerule = client.pagerules.delete( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) @parametrize def test_raw_response_delete(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = client.pagerules.with_raw_response.delete( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + response = client.pagerules.with_raw_response.delete( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -343,78 +317,71 @@ def test_raw_response_delete(self, client: Cloudflare) -> None: @parametrize def test_streaming_response_delete(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with client.pagerules.with_streaming_response.delete( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" + with client.pagerules.with_streaming_response.delete( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) + pagerule = response.parse() + assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_delete(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.delete( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="", - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - client.pagerules.with_raw_response.delete( - pagerule_id="", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - - @parametrize - def test_method_edit(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.edit( + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.pagerules.with_raw_response.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): + client.pagerules.with_raw_response.delete( + pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_edit(self, client: Cloudflare) -> None: + pagerule = client.pagerules.edit( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize def test_method_edit_with_all_params(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.edit( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[ - { - "id": "browser_check", - "value": "on", - } - ], - priority=0, - status="active", - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) - + pagerule = client.pagerules.edit( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[ + { + "id": "browser_check", + "value": "on", + } + ], + priority=0, + status="active", + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize def test_raw_response_edit(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = client.pagerules.with_raw_response.edit( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + response = client.pagerules.with_raw_response.edit( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -423,51 +390,46 @@ def test_raw_response_edit(self, client: Cloudflare) -> None: @parametrize def test_streaming_response_edit(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with client.pagerules.with_streaming_response.edit( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" + with client.pagerules.with_streaming_response.edit( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + pagerule = response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_edit(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.edit( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="", - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - client.pagerules.with_raw_response.edit( - pagerule_id="", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - - @parametrize - def test_method_get(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = client.pagerules.get( + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.pagerules.with_raw_response.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): + client.pagerules.with_raw_response.edit( + pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + def test_method_get(self, client: Cloudflare) -> None: + pagerule = client.pagerules.get( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize def test_raw_response_get(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = client.pagerules.with_raw_response.get( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + response = client.pagerules.with_raw_response.get( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -476,33 +438,31 @@ def test_raw_response_get(self, client: Cloudflare) -> None: @parametrize def test_streaming_response_get(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with client.pagerules.with_streaming_response.get( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" + with client.pagerules.with_streaming_response.get( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + pagerule = response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize def test_path_params_get(self, client: Cloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - client.pagerules.with_raw_response.get( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="", - ) + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + client.pagerules.with_raw_response.get( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="", + ) - with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - client.pagerules.with_raw_response.get( - pagerule_id="", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): + client.pagerules.with_raw_response.get( + pagerule_id="", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) class TestAsyncPagerules: @@ -510,65 +470,60 @@ class TestAsyncPagerules: @parametrize async def test_method_create(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.create( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) - + pagerule = await async_client.pagerules.create( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize async def test_method_create_with_all_params(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.create( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[ - { - "id": "browser_check", - "value": "on", - } - ], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - priority=0, - status="active", - ) - + pagerule = await async_client.pagerules.create( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[ + { + "id": "browser_check", + "value": "on", + } + ], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + priority=0, + status="active", + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize async def test_raw_response_create(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = await async_client.pagerules.with_raw_response.create( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) + response = await async_client.pagerules.with_raw_response.create( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -577,52 +532,32 @@ async def test_raw_response_create(self, async_client: AsyncCloudflare) -> None: @parametrize async def test_streaming_response_create(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - async with async_client.pagerules.with_streaming_response.create( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + async with async_client.pagerules.with_streaming_response.create( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pagerule = await response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_create(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.create( - zone_id="", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) - - @parametrize - async def test_method_update(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.update( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.pagerules.with_raw_response.create( + zone_id="", actions=[{}], targets=[ { @@ -635,41 +570,101 @@ async def test_method_update(self, async_client: AsyncCloudflare) -> None: ], ) + @parametrize + async def test_method_update(self, async_client: AsyncCloudflare) -> None: + pagerule = await async_client.pagerules.update( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize async def test_method_update_with_all_params(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.update( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[ - { - "id": "browser_check", - "value": "on", - } - ], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - priority=0, - status="active", - ) - + pagerule = await async_client.pagerules.update( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[ + { + "id": "browser_check", + "value": "on", + } + ], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + priority=0, + status="active", + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize async def test_raw_response_update(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = await async_client.pagerules.with_raw_response.update( + response = await async_client.pagerules.with_raw_response.update( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) + + assert response.is_closed is True + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + pagerule = await response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + + @parametrize + async def test_streaming_response_update(self, async_client: AsyncCloudflare) -> None: + async with async_client.pagerules.with_streaming_response.update( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[{}], + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" + + pagerule = await response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + + assert cast(Any, response.is_closed) is True + + @parametrize + async def test_path_params_update(self, async_client: AsyncCloudflare) -> None: + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.pagerules.with_raw_response.update( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="", actions=[{}], targets=[ { @@ -682,16 +677,9 @@ async def test_raw_response_update(self, async_client: AsyncCloudflare) -> None: ], ) - assert response.is_closed is True - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) - - @parametrize - async def test_streaming_response_update(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - async with async_client.pagerules.with_streaming_response.update( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): + await async_client.pagerules.with_raw_response.update( + pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", actions=[{}], targets=[ @@ -703,78 +691,31 @@ async def test_streaming_response_update(self, async_client: AsyncCloudflare) -> "target": "url", } ], - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" - - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) - - assert cast(Any, response.is_closed) is True - - @parametrize - async def test_path_params_update(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.update( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - await async_client.pagerules.with_raw_response.update( - pagerule_id="", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[{}], - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) + ) @parametrize async def test_method_list(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - + pagerule = await async_client.pagerules.list( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) @parametrize async def test_method_list_with_all_params(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - direction="asc", - match="any", - order="status", - status="active", - ) - + pagerule = await async_client.pagerules.list( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + direction="asc", + match="any", + order="status", + status="active", + ) assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) @parametrize async def test_raw_response_list(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = await async_client.pagerules.with_raw_response.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + response = await async_client.pagerules.with_raw_response.list( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -783,43 +724,38 @@ async def test_raw_response_list(self, async_client: AsyncCloudflare) -> None: @parametrize async def test_streaming_response_list(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - async with async_client.pagerules.with_streaming_response.list( - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" + async with async_client.pagerules.with_streaming_response.list( + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) + pagerule = await response.parse() + assert_matches_type(Optional[PageruleListResponse], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_list(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.list( - zone_id="", - ) + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.pagerules.with_raw_response.list( + zone_id="", + ) @parametrize async def test_method_delete(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.delete( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - + pagerule = await async_client.pagerules.delete( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) @parametrize async def test_raw_response_delete(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = await async_client.pagerules.with_raw_response.delete( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + response = await async_client.pagerules.with_raw_response.delete( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -828,78 +764,71 @@ async def test_raw_response_delete(self, async_client: AsyncCloudflare) -> None: @parametrize async def test_streaming_response_delete(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - async with async_client.pagerules.with_streaming_response.delete( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" + async with async_client.pagerules.with_streaming_response.delete( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) + pagerule = await response.parse() + assert_matches_type(Optional[PageruleDeleteResponse], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_delete(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.delete( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="", - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - await async_client.pagerules.with_raw_response.delete( - pagerule_id="", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - - @parametrize - async def test_method_edit(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.edit( + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.pagerules.with_raw_response.delete( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): + await async_client.pagerules.with_raw_response.delete( + pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_edit(self, async_client: AsyncCloudflare) -> None: + pagerule = await async_client.pagerules.edit( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize async def test_method_edit_with_all_params(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.edit( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - actions=[ - { - "id": "browser_check", - "value": "on", - } - ], - priority=0, - status="active", - targets=[ - { - "constraint": { - "operator": "matches", - "value": "*example.com/images/*", - }, - "target": "url", - } - ], - ) - + pagerule = await async_client.pagerules.edit( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + actions=[ + { + "id": "browser_check", + "value": "on", + } + ], + priority=0, + status="active", + targets=[ + { + "constraint": { + "operator": "matches", + "value": "*example.com/images/*", + }, + "target": "url", + } + ], + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = await async_client.pagerules.with_raw_response.edit( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + response = await async_client.pagerules.with_raw_response.edit( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -908,51 +837,46 @@ async def test_raw_response_edit(self, async_client: AsyncCloudflare) -> None: @parametrize async def test_streaming_response_edit(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - async with async_client.pagerules.with_streaming_response.edit( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" + async with async_client.pagerules.with_streaming_response.edit( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + pagerule = await response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_edit(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.edit( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="", - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - await async_client.pagerules.with_raw_response.edit( - pagerule_id="", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) - - @parametrize - async def test_method_get(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - pagerule = await async_client.pagerules.get( + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.pagerules.with_raw_response.edit( pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): + await async_client.pagerules.with_raw_response.edit( + pagerule_id="", zone_id="023e105f4ecef8ad9ca31a8372d0c353", ) + @parametrize + async def test_method_get(self, async_client: AsyncCloudflare) -> None: + pagerule = await async_client.pagerules.get( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert_matches_type(Optional[PageRule], pagerule, path=["response"]) @parametrize async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - response = await async_client.pagerules.with_raw_response.get( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + response = await async_client.pagerules.with_raw_response.get( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) assert response.is_closed is True assert response.http_request.headers.get("X-Stainless-Lang") == "python" @@ -961,30 +885,28 @@ async def test_raw_response_get(self, async_client: AsyncCloudflare) -> None: @parametrize async def test_streaming_response_get(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - async with async_client.pagerules.with_streaming_response.get( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) as response: - assert not response.is_closed - assert response.http_request.headers.get("X-Stainless-Lang") == "python" + async with async_client.pagerules.with_streaming_response.get( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + ) as response: + assert not response.is_closed + assert response.http_request.headers.get("X-Stainless-Lang") == "python" - pagerule = await response.parse() - assert_matches_type(Optional[PageRule], pagerule, path=["response"]) + pagerule = await response.parse() + assert_matches_type(Optional[PageRule], pagerule, path=["response"]) assert cast(Any, response.is_closed) is True @parametrize async def test_path_params_get(self, async_client: AsyncCloudflare) -> None: - with pytest.warns(DeprecationWarning): - with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): - await async_client.pagerules.with_raw_response.get( - pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", - zone_id="", - ) - - with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): - await async_client.pagerules.with_raw_response.get( - pagerule_id="", - zone_id="023e105f4ecef8ad9ca31a8372d0c353", - ) + with pytest.raises(ValueError, match=r"Expected a non-empty value for `zone_id` but received ''"): + await async_client.pagerules.with_raw_response.get( + pagerule_id="023e105f4ecef8ad9ca31a8372d0c353", + zone_id="", + ) + + with pytest.raises(ValueError, match=r"Expected a non-empty value for `pagerule_id` but received ''"): + await async_client.pagerules.with_raw_response.get( + pagerule_id="", + zone_id="023e105f4ecef8ad9ca31a8372d0c353", + )