From 6dbed918a54c190cda4e2b7c1c8b56867bde3562 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 16 Dec 2025 04:18:22 +0000 Subject: [PATCH 01/16] chore(internal): add missing files argument to base client --- src/postgrid/_base_client.py | 10 ++++++++-- 1 file changed, 8 insertions(+), 2 deletions(-) diff --git a/src/postgrid/_base_client.py b/src/postgrid/_base_client.py index 614d3cf..5261099 100644 --- a/src/postgrid/_base_client.py +++ b/src/postgrid/_base_client.py @@ -1247,9 +1247,12 @@ def patch( *, cast_to: Type[ResponseT], body: Body | None = None, + files: RequestFiles | None = None, options: RequestOptions = {}, ) -> ResponseT: - opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options) + opts = FinalRequestOptions.construct( + method="patch", url=path, json_data=body, files=to_httpx_files(files), **options + ) return self.request(cast_to, opts) def put( @@ -1767,9 +1770,12 @@ async def patch( *, cast_to: Type[ResponseT], body: Body | None = None, + files: RequestFiles | None = None, options: RequestOptions = {}, ) -> ResponseT: - opts = FinalRequestOptions.construct(method="patch", url=path, json_data=body, **options) + opts = FinalRequestOptions.construct( + method="patch", url=path, json_data=body, files=to_httpx_files(files), **options + ) return await self.request(cast_to, opts) async def put( From 32fb2cceb7859e77a4840e4f45bc782123aa0359 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 17 Dec 2025 05:38:11 +0000 Subject: [PATCH 02/16] chore: speedup initial import --- src/postgrid/_client.py | 206 +++++++++++++++++++++++++++++----------- 1 file changed, 151 insertions(+), 55 deletions(-) diff --git a/src/postgrid/_client.py b/src/postgrid/_client.py index 58281bc..0b0f83d 100644 --- a/src/postgrid/_client.py +++ b/src/postgrid/_client.py @@ -3,7 +3,7 @@ from __future__ import annotations import os -from typing import Any, Mapping +from typing import TYPE_CHECKING, Any, Mapping from typing_extensions import Self, override import httpx @@ -21,8 +21,8 @@ not_given, ) from ._utils import is_given, get_async_library +from ._compat import cached_property from ._version import __version__ -from .resources import address_verification, intl_address_verification from ._streaming import Stream as Stream, AsyncStream as AsyncStream from ._exceptions import APIStatusError from ._base_client import ( @@ -30,7 +30,15 @@ SyncAPIClient, AsyncAPIClient, ) -from .resources.print_mail import print_mail + +if TYPE_CHECKING: + from .resources import print_mail, address_verification, intl_address_verification + from .resources.address_verification import AddressVerificationResource, AsyncAddressVerificationResource + from .resources.print_mail.print_mail import PrintMailResource, AsyncPrintMailResource + from .resources.intl_address_verification import ( + IntlAddressVerificationResource, + AsyncIntlAddressVerificationResource, + ) __all__ = [ "Timeout", @@ -45,12 +53,6 @@ class PostGrid(SyncAPIClient): - address_verification: address_verification.AddressVerificationResource - intl_address_verification: intl_address_verification.IntlAddressVerificationResource - print_mail: print_mail.PrintMailResource - with_raw_response: PostGridWithRawResponse - with_streaming_response: PostGridWithStreamedResponse - # client options address_verification_api_key: str | None print_mail_api_key: str | None @@ -109,11 +111,31 @@ def __init__( _strict_response_validation=_strict_response_validation, ) - self.address_verification = address_verification.AddressVerificationResource(self) - self.intl_address_verification = intl_address_verification.IntlAddressVerificationResource(self) - self.print_mail = print_mail.PrintMailResource(self) - self.with_raw_response = PostGridWithRawResponse(self) - self.with_streaming_response = PostGridWithStreamedResponse(self) + @cached_property + def address_verification(self) -> AddressVerificationResource: + from .resources.address_verification import AddressVerificationResource + + return AddressVerificationResource(self) + + @cached_property + def intl_address_verification(self) -> IntlAddressVerificationResource: + from .resources.intl_address_verification import IntlAddressVerificationResource + + return IntlAddressVerificationResource(self) + + @cached_property + def print_mail(self) -> PrintMailResource: + from .resources.print_mail import PrintMailResource + + return PrintMailResource(self) + + @cached_property + def with_raw_response(self) -> PostGridWithRawResponse: + return PostGridWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> PostGridWithStreamedResponse: + return PostGridWithStreamedResponse(self) @override def _prepare_request( @@ -266,12 +288,6 @@ def _make_status_error( class AsyncPostGrid(AsyncAPIClient): - address_verification: address_verification.AsyncAddressVerificationResource - intl_address_verification: intl_address_verification.AsyncIntlAddressVerificationResource - print_mail: print_mail.AsyncPrintMailResource - with_raw_response: AsyncPostGridWithRawResponse - with_streaming_response: AsyncPostGridWithStreamedResponse - # client options address_verification_api_key: str | None print_mail_api_key: str | None @@ -330,11 +346,31 @@ def __init__( _strict_response_validation=_strict_response_validation, ) - self.address_verification = address_verification.AsyncAddressVerificationResource(self) - self.intl_address_verification = intl_address_verification.AsyncIntlAddressVerificationResource(self) - self.print_mail = print_mail.AsyncPrintMailResource(self) - self.with_raw_response = AsyncPostGridWithRawResponse(self) - self.with_streaming_response = AsyncPostGridWithStreamedResponse(self) + @cached_property + def address_verification(self) -> AsyncAddressVerificationResource: + from .resources.address_verification import AsyncAddressVerificationResource + + return AsyncAddressVerificationResource(self) + + @cached_property + def intl_address_verification(self) -> AsyncIntlAddressVerificationResource: + from .resources.intl_address_verification import AsyncIntlAddressVerificationResource + + return AsyncIntlAddressVerificationResource(self) + + @cached_property + def print_mail(self) -> AsyncPrintMailResource: + from .resources.print_mail import AsyncPrintMailResource + + return AsyncPrintMailResource(self) + + @cached_property + def with_raw_response(self) -> AsyncPostGridWithRawResponse: + return AsyncPostGridWithRawResponse(self) + + @cached_property + def with_streaming_response(self) -> AsyncPostGridWithStreamedResponse: + return AsyncPostGridWithStreamedResponse(self) @override async def _prepare_request( @@ -487,49 +523,109 @@ def _make_status_error( class PostGridWithRawResponse: + _client: PostGrid + def __init__(self, client: PostGrid) -> None: - self.address_verification = address_verification.AddressVerificationResourceWithRawResponse( - client.address_verification - ) - self.intl_address_verification = intl_address_verification.IntlAddressVerificationResourceWithRawResponse( - client.intl_address_verification - ) - self.print_mail = print_mail.PrintMailResourceWithRawResponse(client.print_mail) + self._client = client + + @cached_property + def address_verification(self) -> address_verification.AddressVerificationResourceWithRawResponse: + from .resources.address_verification import AddressVerificationResourceWithRawResponse + + return AddressVerificationResourceWithRawResponse(self._client.address_verification) + + @cached_property + def intl_address_verification(self) -> intl_address_verification.IntlAddressVerificationResourceWithRawResponse: + from .resources.intl_address_verification import IntlAddressVerificationResourceWithRawResponse + + return IntlAddressVerificationResourceWithRawResponse(self._client.intl_address_verification) + + @cached_property + def print_mail(self) -> print_mail.PrintMailResourceWithRawResponse: + from .resources.print_mail import PrintMailResourceWithRawResponse + + return PrintMailResourceWithRawResponse(self._client.print_mail) class AsyncPostGridWithRawResponse: + _client: AsyncPostGrid + def __init__(self, client: AsyncPostGrid) -> None: - self.address_verification = address_verification.AsyncAddressVerificationResourceWithRawResponse( - client.address_verification - ) - self.intl_address_verification = intl_address_verification.AsyncIntlAddressVerificationResourceWithRawResponse( - client.intl_address_verification - ) - self.print_mail = print_mail.AsyncPrintMailResourceWithRawResponse(client.print_mail) + self._client = client + + @cached_property + def address_verification(self) -> address_verification.AsyncAddressVerificationResourceWithRawResponse: + from .resources.address_verification import AsyncAddressVerificationResourceWithRawResponse + + return AsyncAddressVerificationResourceWithRawResponse(self._client.address_verification) + + @cached_property + def intl_address_verification( + self, + ) -> intl_address_verification.AsyncIntlAddressVerificationResourceWithRawResponse: + from .resources.intl_address_verification import AsyncIntlAddressVerificationResourceWithRawResponse + + return AsyncIntlAddressVerificationResourceWithRawResponse(self._client.intl_address_verification) + + @cached_property + def print_mail(self) -> print_mail.AsyncPrintMailResourceWithRawResponse: + from .resources.print_mail import AsyncPrintMailResourceWithRawResponse + + return AsyncPrintMailResourceWithRawResponse(self._client.print_mail) class PostGridWithStreamedResponse: + _client: PostGrid + def __init__(self, client: PostGrid) -> None: - self.address_verification = address_verification.AddressVerificationResourceWithStreamingResponse( - client.address_verification - ) - self.intl_address_verification = intl_address_verification.IntlAddressVerificationResourceWithStreamingResponse( - client.intl_address_verification - ) - self.print_mail = print_mail.PrintMailResourceWithStreamingResponse(client.print_mail) + self._client = client + + @cached_property + def address_verification(self) -> address_verification.AddressVerificationResourceWithStreamingResponse: + from .resources.address_verification import AddressVerificationResourceWithStreamingResponse + + return AddressVerificationResourceWithStreamingResponse(self._client.address_verification) + + @cached_property + def intl_address_verification( + self, + ) -> intl_address_verification.IntlAddressVerificationResourceWithStreamingResponse: + from .resources.intl_address_verification import IntlAddressVerificationResourceWithStreamingResponse + + return IntlAddressVerificationResourceWithStreamingResponse(self._client.intl_address_verification) + + @cached_property + def print_mail(self) -> print_mail.PrintMailResourceWithStreamingResponse: + from .resources.print_mail import PrintMailResourceWithStreamingResponse + + return PrintMailResourceWithStreamingResponse(self._client.print_mail) class AsyncPostGridWithStreamedResponse: + _client: AsyncPostGrid + def __init__(self, client: AsyncPostGrid) -> None: - self.address_verification = address_verification.AsyncAddressVerificationResourceWithStreamingResponse( - client.address_verification - ) - self.intl_address_verification = ( - intl_address_verification.AsyncIntlAddressVerificationResourceWithStreamingResponse( - client.intl_address_verification - ) - ) - self.print_mail = print_mail.AsyncPrintMailResourceWithStreamingResponse(client.print_mail) + self._client = client + + @cached_property + def address_verification(self) -> address_verification.AsyncAddressVerificationResourceWithStreamingResponse: + from .resources.address_verification import AsyncAddressVerificationResourceWithStreamingResponse + + return AsyncAddressVerificationResourceWithStreamingResponse(self._client.address_verification) + + @cached_property + def intl_address_verification( + self, + ) -> intl_address_verification.AsyncIntlAddressVerificationResourceWithStreamingResponse: + from .resources.intl_address_verification import AsyncIntlAddressVerificationResourceWithStreamingResponse + + return AsyncIntlAddressVerificationResourceWithStreamingResponse(self._client.intl_address_verification) + + @cached_property + def print_mail(self) -> print_mail.AsyncPrintMailResourceWithStreamingResponse: + from .resources.print_mail import AsyncPrintMailResourceWithStreamingResponse + + return AsyncPrintMailResourceWithStreamingResponse(self._client.print_mail) Client = PostGrid From a3b137ae1ab33697009d7b508a8d22f7349b9dec Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 18 Dec 2025 06:24:50 +0000 Subject: [PATCH 03/16] fix: use async_to_httpx_files in patch method --- src/postgrid/_base_client.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/postgrid/_base_client.py b/src/postgrid/_base_client.py index 5261099..89aae07 100644 --- a/src/postgrid/_base_client.py +++ b/src/postgrid/_base_client.py @@ -1774,7 +1774,7 @@ async def patch( options: RequestOptions = {}, ) -> ResponseT: opts = FinalRequestOptions.construct( - method="patch", url=path, json_data=body, files=to_httpx_files(files), **options + method="patch", url=path, json_data=body, files=await async_to_httpx_files(files), **options ) return await self.request(cast_to, opts) From e8d9998a7bc735ebb82e4071f479b6d811746abd Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 19 Dec 2025 05:40:55 +0000 Subject: [PATCH 04/16] chore(internal): add `--fix` argument to lint script --- scripts/lint | 9 +++++++-- 1 file changed, 7 insertions(+), 2 deletions(-) diff --git a/scripts/lint b/scripts/lint index 0512393..2483883 100755 --- a/scripts/lint +++ b/scripts/lint @@ -4,8 +4,13 @@ set -e cd "$(dirname "$0")/.." -echo "==> Running lints" -rye run lint +if [ "$1" = "--fix" ]; then + echo "==> Running lints with --fix" + rye run fix:ruff +else + echo "==> Running lints" + rye run lint +fi echo "==> Making sure it imports" rye run python -c 'import postgrid' From eb02a837ede94d5440593cb9c921c6e47ae5a0ab Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Tue, 6 Jan 2026 05:08:28 +0000 Subject: [PATCH 05/16] chore(internal): codegen related update --- LICENSE | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/LICENSE b/LICENSE index ab63a50..1a60946 100644 --- a/LICENSE +++ b/LICENSE @@ -186,7 +186,7 @@ same "printed page" as the copyright notice for easier identification within third-party archives. - Copyright 2025 PostGrid + Copyright 2026 PostGrid Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. From af955ca7182b4f032d6d9c10faf060668fa43248 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 8 Jan 2026 05:03:36 +0000 Subject: [PATCH 06/16] fix(client): loosen auth header validation --- src/postgrid/_client.py | 18 ++---------------- 1 file changed, 2 insertions(+), 16 deletions(-) diff --git a/src/postgrid/_client.py b/src/postgrid/_client.py index 0b0f83d..b292045 100644 --- a/src/postgrid/_client.py +++ b/src/postgrid/_client.py @@ -186,14 +186,7 @@ def default_headers(self) -> dict[str, str | Omit]: @override def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None: - if self.address_verification_api_key and headers.get("X-API-Key"): - return - if isinstance(custom_headers.get("X-API-Key"), Omit): - return - - if self.print_mail_api_key and headers.get("X-API-Key"): - return - if isinstance(custom_headers.get("X-API-Key"), Omit): + if headers.get("X-API-Key") or isinstance(custom_headers.get("X-API-Key"), Omit): return raise TypeError( @@ -421,14 +414,7 @@ def default_headers(self) -> dict[str, str | Omit]: @override def _validate_headers(self, headers: Headers, custom_headers: Headers) -> None: - if self.address_verification_api_key and headers.get("X-API-Key"): - return - if isinstance(custom_headers.get("X-API-Key"), Omit): - return - - if self.print_mail_api_key and headers.get("X-API-Key"): - return - if isinstance(custom_headers.get("X-API-Key"), Omit): + if headers.get("X-API-Key") or isinstance(custom_headers.get("X-API-Key"), Omit): return raise TypeError( From 9c92b6a0f2411b015adf447dffa582836bc1ac4a Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 14 Jan 2026 07:17:57 +0000 Subject: [PATCH 07/16] feat(client): add support for binary request streaming --- src/postgrid/_base_client.py | 145 +++++++++++++++++++++++++-- src/postgrid/_models.py | 17 +++- src/postgrid/_types.py | 9 ++ tests/test_client.py | 189 ++++++++++++++++++++++++++++++++++- 4 files changed, 346 insertions(+), 14 deletions(-) diff --git a/src/postgrid/_base_client.py b/src/postgrid/_base_client.py index 89aae07..15aaf61 100644 --- a/src/postgrid/_base_client.py +++ b/src/postgrid/_base_client.py @@ -9,6 +9,7 @@ import inspect import logging import platform +import warnings import email.utils from types import TracebackType from random import random @@ -51,9 +52,11 @@ ResponseT, AnyMapping, PostParser, + BinaryTypes, RequestFiles, HttpxSendArgs, RequestOptions, + AsyncBinaryTypes, HttpxRequestFiles, ModelBuilderProtocol, not_given, @@ -477,8 +480,19 @@ def _build_request( retries_taken: int = 0, ) -> httpx.Request: if log.isEnabledFor(logging.DEBUG): - log.debug("Request options: %s", model_dump(options, exclude_unset=True)) - + log.debug( + "Request options: %s", + model_dump( + options, + exclude_unset=True, + # Pydantic v1 can't dump every type we support in content, so we exclude it for now. + exclude={ + "content", + } + if PYDANTIC_V1 + else {}, + ), + ) kwargs: dict[str, Any] = {} json_data = options.json_data @@ -532,7 +546,13 @@ def _build_request( is_body_allowed = options.method.lower() != "get" if is_body_allowed: - if isinstance(json_data, bytes): + if options.content is not None and json_data is not None: + raise TypeError("Passing both `content` and `json_data` is not supported") + if options.content is not None and files is not None: + raise TypeError("Passing both `content` and `files` is not supported") + if options.content is not None: + kwargs["content"] = options.content + elif isinstance(json_data, bytes): kwargs["content"] = json_data else: kwargs["json"] = json_data if is_given(json_data) else None @@ -1194,6 +1214,7 @@ def post( *, cast_to: Type[ResponseT], body: Body | None = None, + content: BinaryTypes | None = None, options: RequestOptions = {}, files: RequestFiles | None = None, stream: Literal[False] = False, @@ -1206,6 +1227,7 @@ def post( *, cast_to: Type[ResponseT], body: Body | None = None, + content: BinaryTypes | None = None, options: RequestOptions = {}, files: RequestFiles | None = None, stream: Literal[True], @@ -1219,6 +1241,7 @@ def post( *, cast_to: Type[ResponseT], body: Body | None = None, + content: BinaryTypes | None = None, options: RequestOptions = {}, files: RequestFiles | None = None, stream: bool, @@ -1231,13 +1254,25 @@ def post( *, cast_to: Type[ResponseT], body: Body | None = None, + content: BinaryTypes | None = None, options: RequestOptions = {}, files: RequestFiles | None = None, stream: bool = False, stream_cls: type[_StreamT] | None = None, ) -> ResponseT | _StreamT: + if body is not None and content is not None: + raise TypeError("Passing both `body` and `content` is not supported") + if files is not None and content is not None: + raise TypeError("Passing both `files` and `content` is not supported") + if isinstance(body, bytes): + warnings.warn( + "Passing raw bytes as `body` is deprecated and will be removed in a future version. " + "Please pass raw bytes via the `content` parameter instead.", + DeprecationWarning, + stacklevel=2, + ) opts = FinalRequestOptions.construct( - method="post", url=path, json_data=body, files=to_httpx_files(files), **options + method="post", url=path, json_data=body, content=content, files=to_httpx_files(files), **options ) return cast(ResponseT, self.request(cast_to, opts, stream=stream, stream_cls=stream_cls)) @@ -1247,11 +1282,23 @@ def patch( *, cast_to: Type[ResponseT], body: Body | None = None, + content: BinaryTypes | None = None, files: RequestFiles | None = None, options: RequestOptions = {}, ) -> ResponseT: + if body is not None and content is not None: + raise TypeError("Passing both `body` and `content` is not supported") + if files is not None and content is not None: + raise TypeError("Passing both `files` and `content` is not supported") + if isinstance(body, bytes): + warnings.warn( + "Passing raw bytes as `body` is deprecated and will be removed in a future version. " + "Please pass raw bytes via the `content` parameter instead.", + DeprecationWarning, + stacklevel=2, + ) opts = FinalRequestOptions.construct( - method="patch", url=path, json_data=body, files=to_httpx_files(files), **options + method="patch", url=path, json_data=body, content=content, files=to_httpx_files(files), **options ) return self.request(cast_to, opts) @@ -1261,11 +1308,23 @@ def put( *, cast_to: Type[ResponseT], body: Body | None = None, + content: BinaryTypes | None = None, files: RequestFiles | None = None, options: RequestOptions = {}, ) -> ResponseT: + if body is not None and content is not None: + raise TypeError("Passing both `body` and `content` is not supported") + if files is not None and content is not None: + raise TypeError("Passing both `files` and `content` is not supported") + if isinstance(body, bytes): + warnings.warn( + "Passing raw bytes as `body` is deprecated and will be removed in a future version. " + "Please pass raw bytes via the `content` parameter instead.", + DeprecationWarning, + stacklevel=2, + ) opts = FinalRequestOptions.construct( - method="put", url=path, json_data=body, files=to_httpx_files(files), **options + method="put", url=path, json_data=body, content=content, files=to_httpx_files(files), **options ) return self.request(cast_to, opts) @@ -1275,9 +1334,19 @@ def delete( *, cast_to: Type[ResponseT], body: Body | None = None, + content: BinaryTypes | None = None, options: RequestOptions = {}, ) -> ResponseT: - opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, **options) + if body is not None and content is not None: + raise TypeError("Passing both `body` and `content` is not supported") + if isinstance(body, bytes): + warnings.warn( + "Passing raw bytes as `body` is deprecated and will be removed in a future version. " + "Please pass raw bytes via the `content` parameter instead.", + DeprecationWarning, + stacklevel=2, + ) + opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, content=content, **options) return self.request(cast_to, opts) def get_api_list( @@ -1717,6 +1786,7 @@ async def post( *, cast_to: Type[ResponseT], body: Body | None = None, + content: AsyncBinaryTypes | None = None, files: RequestFiles | None = None, options: RequestOptions = {}, stream: Literal[False] = False, @@ -1729,6 +1799,7 @@ async def post( *, cast_to: Type[ResponseT], body: Body | None = None, + content: AsyncBinaryTypes | None = None, files: RequestFiles | None = None, options: RequestOptions = {}, stream: Literal[True], @@ -1742,6 +1813,7 @@ async def post( *, cast_to: Type[ResponseT], body: Body | None = None, + content: AsyncBinaryTypes | None = None, files: RequestFiles | None = None, options: RequestOptions = {}, stream: bool, @@ -1754,13 +1826,25 @@ async def post( *, cast_to: Type[ResponseT], body: Body | None = None, + content: AsyncBinaryTypes | None = None, files: RequestFiles | None = None, options: RequestOptions = {}, stream: bool = False, stream_cls: type[_AsyncStreamT] | None = None, ) -> ResponseT | _AsyncStreamT: + if body is not None and content is not None: + raise TypeError("Passing both `body` and `content` is not supported") + if files is not None and content is not None: + raise TypeError("Passing both `files` and `content` is not supported") + if isinstance(body, bytes): + warnings.warn( + "Passing raw bytes as `body` is deprecated and will be removed in a future version. " + "Please pass raw bytes via the `content` parameter instead.", + DeprecationWarning, + stacklevel=2, + ) opts = FinalRequestOptions.construct( - method="post", url=path, json_data=body, files=await async_to_httpx_files(files), **options + method="post", url=path, json_data=body, content=content, files=await async_to_httpx_files(files), **options ) return await self.request(cast_to, opts, stream=stream, stream_cls=stream_cls) @@ -1770,11 +1854,28 @@ async def patch( *, cast_to: Type[ResponseT], body: Body | None = None, + content: AsyncBinaryTypes | None = None, files: RequestFiles | None = None, options: RequestOptions = {}, ) -> ResponseT: + if body is not None and content is not None: + raise TypeError("Passing both `body` and `content` is not supported") + if files is not None and content is not None: + raise TypeError("Passing both `files` and `content` is not supported") + if isinstance(body, bytes): + warnings.warn( + "Passing raw bytes as `body` is deprecated and will be removed in a future version. " + "Please pass raw bytes via the `content` parameter instead.", + DeprecationWarning, + stacklevel=2, + ) opts = FinalRequestOptions.construct( - method="patch", url=path, json_data=body, files=await async_to_httpx_files(files), **options + method="patch", + url=path, + json_data=body, + content=content, + files=await async_to_httpx_files(files), + **options, ) return await self.request(cast_to, opts) @@ -1784,11 +1885,23 @@ async def put( *, cast_to: Type[ResponseT], body: Body | None = None, + content: AsyncBinaryTypes | None = None, files: RequestFiles | None = None, options: RequestOptions = {}, ) -> ResponseT: + if body is not None and content is not None: + raise TypeError("Passing both `body` and `content` is not supported") + if files is not None and content is not None: + raise TypeError("Passing both `files` and `content` is not supported") + if isinstance(body, bytes): + warnings.warn( + "Passing raw bytes as `body` is deprecated and will be removed in a future version. " + "Please pass raw bytes via the `content` parameter instead.", + DeprecationWarning, + stacklevel=2, + ) opts = FinalRequestOptions.construct( - method="put", url=path, json_data=body, files=await async_to_httpx_files(files), **options + method="put", url=path, json_data=body, content=content, files=await async_to_httpx_files(files), **options ) return await self.request(cast_to, opts) @@ -1798,9 +1911,19 @@ async def delete( *, cast_to: Type[ResponseT], body: Body | None = None, + content: AsyncBinaryTypes | None = None, options: RequestOptions = {}, ) -> ResponseT: - opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, **options) + if body is not None and content is not None: + raise TypeError("Passing both `body` and `content` is not supported") + if isinstance(body, bytes): + warnings.warn( + "Passing raw bytes as `body` is deprecated and will be removed in a future version. " + "Please pass raw bytes via the `content` parameter instead.", + DeprecationWarning, + stacklevel=2, + ) + opts = FinalRequestOptions.construct(method="delete", url=path, json_data=body, content=content, **options) return await self.request(cast_to, opts) def get_api_list( diff --git a/src/postgrid/_models.py b/src/postgrid/_models.py index ca9500b..29070e0 100644 --- a/src/postgrid/_models.py +++ b/src/postgrid/_models.py @@ -3,7 +3,20 @@ import os import inspect import weakref -from typing import TYPE_CHECKING, Any, Type, Union, Generic, TypeVar, Callable, Optional, cast +from typing import ( + IO, + TYPE_CHECKING, + Any, + Type, + Union, + Generic, + TypeVar, + Callable, + Iterable, + Optional, + AsyncIterable, + cast, +) from datetime import date, datetime from typing_extensions import ( List, @@ -787,6 +800,7 @@ class FinalRequestOptionsInput(TypedDict, total=False): timeout: float | Timeout | None files: HttpxRequestFiles | None idempotency_key: str + content: Union[bytes, bytearray, IO[bytes], Iterable[bytes], AsyncIterable[bytes], None] json_data: Body extra_json: AnyMapping follow_redirects: bool @@ -805,6 +819,7 @@ class FinalRequestOptions(pydantic.BaseModel): post_parser: Union[Callable[[Any], Any], NotGiven] = NotGiven() follow_redirects: Union[bool, None] = None + content: Union[bytes, bytearray, IO[bytes], Iterable[bytes], AsyncIterable[bytes], None] = None # It should be noted that we cannot use `json` here as that would override # a BaseModel method in an incompatible fashion. json_data: Union[Body, None] = None diff --git a/src/postgrid/_types.py b/src/postgrid/_types.py index 7be3f6a..ce5c982 100644 --- a/src/postgrid/_types.py +++ b/src/postgrid/_types.py @@ -13,9 +13,11 @@ Mapping, TypeVar, Callable, + Iterable, Iterator, Optional, Sequence, + AsyncIterable, ) from typing_extensions import ( Set, @@ -56,6 +58,13 @@ else: Base64FileInput = Union[IO[bytes], PathLike] FileContent = Union[IO[bytes], bytes, PathLike] # PathLike is not subscriptable in Python 3.8. + + +# Used for sending raw binary data / streaming data in request bodies +# e.g. for file uploads without multipart encoding +BinaryTypes = Union[bytes, bytearray, IO[bytes], Iterable[bytes]] +AsyncBinaryTypes = Union[bytes, bytearray, IO[bytes], AsyncIterable[bytes]] + FileTypes = Union[ # file (or bytes) FileContent, diff --git a/tests/test_client.py b/tests/test_client.py index 937363b..e21e154 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -8,10 +8,11 @@ import json import asyncio import inspect +import dataclasses import tracemalloc -from typing import Any, Union, cast +from typing import Any, Union, TypeVar, Callable, Iterable, Iterator, Optional, Coroutine, cast from unittest import mock -from typing_extensions import Literal +from typing_extensions import Literal, AsyncIterator, override import httpx import pytest @@ -36,6 +37,7 @@ from .utils import update_env +T = TypeVar("T") base_url = os.environ.get("TEST_API_BASE_URL", "http://127.0.0.1:4010") address_verification_api_key = "My Address Verification API Key" print_mail_api_key = "My Print Mail API Key" @@ -51,6 +53,57 @@ def _low_retry_timeout(*_args: Any, **_kwargs: Any) -> float: return 0.1 +def mirror_request_content(request: httpx.Request) -> httpx.Response: + return httpx.Response(200, content=request.content) + + +# note: we can't use the httpx.MockTransport class as it consumes the request +# body itself, which means we can't test that the body is read lazily +class MockTransport(httpx.BaseTransport, httpx.AsyncBaseTransport): + def __init__( + self, + handler: Callable[[httpx.Request], httpx.Response] + | Callable[[httpx.Request], Coroutine[Any, Any, httpx.Response]], + ) -> None: + self.handler = handler + + @override + def handle_request( + self, + request: httpx.Request, + ) -> httpx.Response: + assert not inspect.iscoroutinefunction(self.handler), "handler must not be a coroutine function" + assert inspect.isfunction(self.handler), "handler must be a function" + return self.handler(request) + + @override + async def handle_async_request( + self, + request: httpx.Request, + ) -> httpx.Response: + assert inspect.iscoroutinefunction(self.handler), "handler must be a coroutine function" + return await self.handler(request) + + +@dataclasses.dataclass +class Counter: + value: int = 0 + + +def _make_sync_iterator(iterable: Iterable[T], counter: Optional[Counter] = None) -> Iterator[T]: + for item in iterable: + if counter: + counter.value += 1 + yield item + + +async def _make_async_iterator(iterable: Iterable[T], counter: Optional[Counter] = None) -> AsyncIterator[T]: + for item in iterable: + if counter: + counter.value += 1 + yield item + + def _get_open_connections(client: PostGrid | AsyncPostGrid) -> int: transport = client._client._transport assert isinstance(transport, httpx.HTTPTransport) or isinstance(transport, httpx.AsyncHTTPTransport) @@ -567,6 +620,71 @@ def test_multipart_repeating_array(self, client: PostGrid) -> None: b"", ] + @pytest.mark.respx(base_url=base_url) + def test_binary_content_upload(self, respx_mock: MockRouter, client: PostGrid) -> None: + respx_mock.post("/upload").mock(side_effect=mirror_request_content) + + file_content = b"Hello, this is a test file." + + response = client.post( + "/upload", + content=file_content, + cast_to=httpx.Response, + options={"headers": {"Content-Type": "application/octet-stream"}}, + ) + + assert response.status_code == 200 + assert response.request.headers["Content-Type"] == "application/octet-stream" + assert response.content == file_content + + def test_binary_content_upload_with_iterator(self) -> None: + file_content = b"Hello, this is a test file." + counter = Counter() + iterator = _make_sync_iterator([file_content], counter=counter) + + def mock_handler(request: httpx.Request) -> httpx.Response: + assert counter.value == 0, "the request body should not have been read" + return httpx.Response(200, content=request.read()) + + with PostGrid( + base_url=base_url, + address_verification_api_key=address_verification_api_key, + print_mail_api_key=print_mail_api_key, + _strict_response_validation=True, + http_client=httpx.Client(transport=MockTransport(handler=mock_handler)), + ) as client: + response = client.post( + "/upload", + content=iterator, + cast_to=httpx.Response, + options={"headers": {"Content-Type": "application/octet-stream"}}, + ) + + assert response.status_code == 200 + assert response.request.headers["Content-Type"] == "application/octet-stream" + assert response.content == file_content + assert counter.value == 1 + + @pytest.mark.respx(base_url=base_url) + def test_binary_content_upload_with_body_is_deprecated(self, respx_mock: MockRouter, client: PostGrid) -> None: + respx_mock.post("/upload").mock(side_effect=mirror_request_content) + + file_content = b"Hello, this is a test file." + + with pytest.deprecated_call( + match="Passing raw bytes as `body` is deprecated and will be removed in a future version. Please pass raw bytes via the `content` parameter instead." + ): + response = client.post( + "/upload", + body=file_content, + cast_to=httpx.Response, + options={"headers": {"Content-Type": "application/octet-stream"}}, + ) + + assert response.status_code == 200 + assert response.request.headers["Content-Type"] == "application/octet-stream" + assert response.content == file_content + @pytest.mark.respx(base_url=base_url) def test_basic_union_response(self, respx_mock: MockRouter, client: PostGrid) -> None: class Model1(BaseModel): @@ -1507,6 +1625,73 @@ def test_multipart_repeating_array(self, async_client: AsyncPostGrid) -> None: b"", ] + @pytest.mark.respx(base_url=base_url) + async def test_binary_content_upload(self, respx_mock: MockRouter, async_client: AsyncPostGrid) -> None: + respx_mock.post("/upload").mock(side_effect=mirror_request_content) + + file_content = b"Hello, this is a test file." + + response = await async_client.post( + "/upload", + content=file_content, + cast_to=httpx.Response, + options={"headers": {"Content-Type": "application/octet-stream"}}, + ) + + assert response.status_code == 200 + assert response.request.headers["Content-Type"] == "application/octet-stream" + assert response.content == file_content + + async def test_binary_content_upload_with_asynciterator(self) -> None: + file_content = b"Hello, this is a test file." + counter = Counter() + iterator = _make_async_iterator([file_content], counter=counter) + + async def mock_handler(request: httpx.Request) -> httpx.Response: + assert counter.value == 0, "the request body should not have been read" + return httpx.Response(200, content=await request.aread()) + + async with AsyncPostGrid( + base_url=base_url, + address_verification_api_key=address_verification_api_key, + print_mail_api_key=print_mail_api_key, + _strict_response_validation=True, + http_client=httpx.AsyncClient(transport=MockTransport(handler=mock_handler)), + ) as client: + response = await client.post( + "/upload", + content=iterator, + cast_to=httpx.Response, + options={"headers": {"Content-Type": "application/octet-stream"}}, + ) + + assert response.status_code == 200 + assert response.request.headers["Content-Type"] == "application/octet-stream" + assert response.content == file_content + assert counter.value == 1 + + @pytest.mark.respx(base_url=base_url) + async def test_binary_content_upload_with_body_is_deprecated( + self, respx_mock: MockRouter, async_client: AsyncPostGrid + ) -> None: + respx_mock.post("/upload").mock(side_effect=mirror_request_content) + + file_content = b"Hello, this is a test file." + + with pytest.deprecated_call( + match="Passing raw bytes as `body` is deprecated and will be removed in a future version. Please pass raw bytes via the `content` parameter instead." + ): + response = await async_client.post( + "/upload", + body=file_content, + cast_to=httpx.Response, + options={"headers": {"Content-Type": "application/octet-stream"}}, + ) + + assert response.status_code == 200 + assert response.request.headers["Content-Type"] == "application/octet-stream" + assert response.content == file_content + @pytest.mark.respx(base_url=base_url) async def test_basic_union_response(self, respx_mock: MockRouter, async_client: AsyncPostGrid) -> None: class Model1(BaseModel): From 0d1728886ee999032574dd9877bc85c84930bc3b Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 17 Jan 2026 05:46:42 +0000 Subject: [PATCH 08/16] chore(internal): update `actions/checkout` version --- .github/workflows/ci.yml | 6 +++--- .github/workflows/publish-pypi.yml | 2 +- .github/workflows/release-doctor.yml | 2 +- 3 files changed, 5 insertions(+), 5 deletions(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 77fd8e0..596a663 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -19,7 +19,7 @@ jobs: runs-on: ${{ github.repository == 'stainless-sdks/postgrid-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }} if: github.event_name == 'push' || github.event.pull_request.head.repo.fork steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - name: Install Rye run: | @@ -44,7 +44,7 @@ jobs: id-token: write runs-on: ${{ github.repository == 'stainless-sdks/postgrid-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }} steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - name: Install Rye run: | @@ -81,7 +81,7 @@ jobs: runs-on: ${{ github.repository == 'stainless-sdks/postgrid-python' && 'depot-ubuntu-24.04' || 'ubuntu-latest' }} if: github.event_name == 'push' || github.event.pull_request.head.repo.fork steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - name: Install Rye run: | diff --git a/.github/workflows/publish-pypi.yml b/.github/workflows/publish-pypi.yml index dcaf2d4..a674d45 100644 --- a/.github/workflows/publish-pypi.yml +++ b/.github/workflows/publish-pypi.yml @@ -14,7 +14,7 @@ jobs: runs-on: ubuntu-latest steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - name: Install Rye run: | diff --git a/.github/workflows/release-doctor.yml b/.github/workflows/release-doctor.yml index 69b5676..7d1fa04 100644 --- a/.github/workflows/release-doctor.yml +++ b/.github/workflows/release-doctor.yml @@ -12,7 +12,7 @@ jobs: if: github.repository == 'postgrid/postgrid-python' && (github.event_name == 'push' || github.event_name == 'workflow_dispatch' || startsWith(github.head_ref, 'release-please') || github.head_ref == 'next') steps: - - uses: actions/checkout@v4 + - uses: actions/checkout@v6 - name: Check release environment run: | From e2ea5fdecfc467358d53198d37f153ea7f7bf0cf Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Sat, 24 Jan 2026 05:14:09 +0000 Subject: [PATCH 09/16] chore(ci): upgrade `actions/github-script` --- .github/workflows/ci.yml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 596a663..ac8c55b 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -63,7 +63,7 @@ jobs: - name: Get GitHub OIDC Token if: github.repository == 'stainless-sdks/postgrid-python' id: github-oidc - uses: actions/github-script@v6 + uses: actions/github-script@v8 with: script: core.setOutput('github_token', await core.getIDToken()); From 7daf14d1ea87c9036961bbcc15399e90ed118cbb Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Fri, 30 Jan 2026 05:05:09 +0000 Subject: [PATCH 10/16] feat(client): add custom JSON encoder for extended type support --- src/postgrid/_base_client.py | 7 +- src/postgrid/_compat.py | 6 +- src/postgrid/_utils/_json.py | 35 ++++++++++ tests/test_utils/test_json.py | 126 ++++++++++++++++++++++++++++++++++ 4 files changed, 169 insertions(+), 5 deletions(-) create mode 100644 src/postgrid/_utils/_json.py create mode 100644 tests/test_utils/test_json.py diff --git a/src/postgrid/_base_client.py b/src/postgrid/_base_client.py index 15aaf61..0dc721f 100644 --- a/src/postgrid/_base_client.py +++ b/src/postgrid/_base_client.py @@ -86,6 +86,7 @@ APIConnectionError, APIResponseValidationError, ) +from ._utils._json import openapi_dumps log: logging.Logger = logging.getLogger(__name__) @@ -554,8 +555,10 @@ def _build_request( kwargs["content"] = options.content elif isinstance(json_data, bytes): kwargs["content"] = json_data - else: - kwargs["json"] = json_data if is_given(json_data) else None + elif not files: + # Don't set content when JSON is sent as multipart/form-data, + # since httpx's content param overrides other body arguments + kwargs["content"] = openapi_dumps(json_data) if is_given(json_data) and json_data is not None else None kwargs["files"] = files else: headers.pop("Content-Type", None) diff --git a/src/postgrid/_compat.py b/src/postgrid/_compat.py index bdef67f..786ff42 100644 --- a/src/postgrid/_compat.py +++ b/src/postgrid/_compat.py @@ -139,6 +139,7 @@ def model_dump( exclude_defaults: bool = False, warnings: bool = True, mode: Literal["json", "python"] = "python", + by_alias: bool | None = None, ) -> dict[str, Any]: if (not PYDANTIC_V1) or hasattr(model, "model_dump"): return model.model_dump( @@ -148,13 +149,12 @@ def model_dump( exclude_defaults=exclude_defaults, # warnings are not supported in Pydantic v1 warnings=True if PYDANTIC_V1 else warnings, + by_alias=by_alias, ) return cast( "dict[str, Any]", model.dict( # pyright: ignore[reportDeprecated, reportUnnecessaryCast] - exclude=exclude, - exclude_unset=exclude_unset, - exclude_defaults=exclude_defaults, + exclude=exclude, exclude_unset=exclude_unset, exclude_defaults=exclude_defaults, by_alias=bool(by_alias) ), ) diff --git a/src/postgrid/_utils/_json.py b/src/postgrid/_utils/_json.py new file mode 100644 index 0000000..6058421 --- /dev/null +++ b/src/postgrid/_utils/_json.py @@ -0,0 +1,35 @@ +import json +from typing import Any +from datetime import datetime +from typing_extensions import override + +import pydantic + +from .._compat import model_dump + + +def openapi_dumps(obj: Any) -> bytes: + """ + Serialize an object to UTF-8 encoded JSON bytes. + + Extends the standard json.dumps with support for additional types + commonly used in the SDK, such as `datetime`, `pydantic.BaseModel`, etc. + """ + return json.dumps( + obj, + cls=_CustomEncoder, + # Uses the same defaults as httpx's JSON serialization + ensure_ascii=False, + separators=(",", ":"), + allow_nan=False, + ).encode() + + +class _CustomEncoder(json.JSONEncoder): + @override + def default(self, o: Any) -> Any: + if isinstance(o, datetime): + return o.isoformat() + if isinstance(o, pydantic.BaseModel): + return model_dump(o, exclude_unset=True, mode="json", by_alias=True) + return super().default(o) diff --git a/tests/test_utils/test_json.py b/tests/test_utils/test_json.py new file mode 100644 index 0000000..97f987b --- /dev/null +++ b/tests/test_utils/test_json.py @@ -0,0 +1,126 @@ +from __future__ import annotations + +import datetime +from typing import Union + +import pydantic + +from postgrid import _compat +from postgrid._utils._json import openapi_dumps + + +class TestOpenapiDumps: + def test_basic(self) -> None: + data = {"key": "value", "number": 42} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"key":"value","number":42}' + + def test_datetime_serialization(self) -> None: + dt = datetime.datetime(2023, 1, 1, 12, 0, 0) + data = {"datetime": dt} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"datetime":"2023-01-01T12:00:00"}' + + def test_pydantic_model_serialization(self) -> None: + class User(pydantic.BaseModel): + first_name: str + last_name: str + age: int + + model_instance = User(first_name="John", last_name="Kramer", age=83) + data = {"model": model_instance} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"model":{"first_name":"John","last_name":"Kramer","age":83}}' + + def test_pydantic_model_with_default_values(self) -> None: + class User(pydantic.BaseModel): + name: str + role: str = "user" + active: bool = True + score: int = 0 + + model_instance = User(name="Alice") + data = {"model": model_instance} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"model":{"name":"Alice"}}' + + def test_pydantic_model_with_default_values_overridden(self) -> None: + class User(pydantic.BaseModel): + name: str + role: str = "user" + active: bool = True + + model_instance = User(name="Bob", role="admin", active=False) + data = {"model": model_instance} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"model":{"name":"Bob","role":"admin","active":false}}' + + def test_pydantic_model_with_alias(self) -> None: + class User(pydantic.BaseModel): + first_name: str = pydantic.Field(alias="firstName") + last_name: str = pydantic.Field(alias="lastName") + + model_instance = User(firstName="John", lastName="Doe") + data = {"model": model_instance} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"model":{"firstName":"John","lastName":"Doe"}}' + + def test_pydantic_model_with_alias_and_default(self) -> None: + class User(pydantic.BaseModel): + user_name: str = pydantic.Field(alias="userName") + user_role: str = pydantic.Field(default="member", alias="userRole") + is_active: bool = pydantic.Field(default=True, alias="isActive") + + model_instance = User(userName="charlie") + data = {"model": model_instance} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"model":{"userName":"charlie"}}' + + model_with_overrides = User(userName="diana", userRole="admin", isActive=False) + data = {"model": model_with_overrides} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"model":{"userName":"diana","userRole":"admin","isActive":false}}' + + def test_pydantic_model_with_nested_models_and_defaults(self) -> None: + class Address(pydantic.BaseModel): + street: str + city: str = "Unknown" + + class User(pydantic.BaseModel): + name: str + address: Address + verified: bool = False + + if _compat.PYDANTIC_V1: + # to handle forward references in Pydantic v1 + User.update_forward_refs(**locals()) # type: ignore[reportDeprecated] + + address = Address(street="123 Main St") + user = User(name="Diana", address=address) + data = {"user": user} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"user":{"name":"Diana","address":{"street":"123 Main St"}}}' + + address_with_city = Address(street="456 Oak Ave", city="Boston") + user_verified = User(name="Eve", address=address_with_city, verified=True) + data = {"user": user_verified} + json_bytes = openapi_dumps(data) + assert ( + json_bytes == b'{"user":{"name":"Eve","address":{"street":"456 Oak Ave","city":"Boston"},"verified":true}}' + ) + + def test_pydantic_model_with_optional_fields(self) -> None: + class User(pydantic.BaseModel): + name: str + email: Union[str, None] + phone: Union[str, None] + + model_with_none = User(name="Eve", email=None, phone=None) + data = {"model": model_with_none} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"model":{"name":"Eve","email":null,"phone":null}}' + + model_with_values = User(name="Frank", email="frank@example.com", phone=None) + data = {"model": model_with_values} + json_bytes = openapi_dumps(data) + assert json_bytes == b'{"model":{"name":"Frank","email":"frank@example.com","phone":null}}' From 53cb8a03ab0c3d88881b7c2acdde5288f8511f7e Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Mon, 9 Feb 2026 14:36:57 +0000 Subject: [PATCH 11/16] chore(internal): bump dependencies --- requirements-dev.lock | 20 ++++++++++---------- requirements.lock | 8 ++++---- 2 files changed, 14 insertions(+), 14 deletions(-) diff --git a/requirements-dev.lock b/requirements-dev.lock index 9e581ce..b05a3be 100644 --- a/requirements-dev.lock +++ b/requirements-dev.lock @@ -12,14 +12,14 @@ -e file:. aiohappyeyeballs==2.6.1 # via aiohttp -aiohttp==3.13.2 +aiohttp==3.13.3 # via httpx-aiohttp # via postgrid-python aiosignal==1.4.0 # via aiohttp annotated-types==0.7.0 # via pydantic -anyio==4.12.0 +anyio==4.12.1 # via httpx # via postgrid-python argcomplete==3.6.3 @@ -31,7 +31,7 @@ attrs==25.4.0 # via nox backports-asyncio-runner==1.2.0 # via pytest-asyncio -certifi==2025.11.12 +certifi==2026.1.4 # via httpcore # via httpx colorlog==6.10.1 @@ -61,7 +61,7 @@ httpx==0.28.1 # via httpx-aiohttp # via postgrid-python # via respx -httpx-aiohttp==0.1.9 +httpx-aiohttp==0.1.12 # via postgrid-python humanize==4.13.0 # via nox @@ -69,7 +69,7 @@ idna==3.11 # via anyio # via httpx # via yarl -importlib-metadata==8.7.0 +importlib-metadata==8.7.1 iniconfig==2.1.0 # via pytest markdown-it-py==3.0.0 @@ -82,14 +82,14 @@ multidict==6.7.0 mypy==1.17.0 mypy-extensions==1.1.0 # via mypy -nodeenv==1.9.1 +nodeenv==1.10.0 # via pyright nox==2025.11.12 packaging==25.0 # via dependency-groups # via nox # via pytest -pathspec==0.12.1 +pathspec==1.0.3 # via mypy platformdirs==4.4.0 # via virtualenv @@ -115,13 +115,13 @@ python-dateutil==2.9.0.post0 # via time-machine respx==0.22.0 rich==14.2.0 -ruff==0.14.7 +ruff==0.14.13 six==1.17.0 # via python-dateutil sniffio==1.3.1 # via postgrid-python time-machine==2.19.0 -tomli==2.3.0 +tomli==2.4.0 # via dependency-groups # via mypy # via nox @@ -141,7 +141,7 @@ typing-extensions==4.15.0 # via virtualenv typing-inspection==0.4.2 # via pydantic -virtualenv==20.35.4 +virtualenv==20.36.1 # via nox yarl==1.22.0 # via aiohttp diff --git a/requirements.lock b/requirements.lock index 5b4dd02..9784b78 100644 --- a/requirements.lock +++ b/requirements.lock @@ -12,21 +12,21 @@ -e file:. aiohappyeyeballs==2.6.1 # via aiohttp -aiohttp==3.13.2 +aiohttp==3.13.3 # via httpx-aiohttp # via postgrid-python aiosignal==1.4.0 # via aiohttp annotated-types==0.7.0 # via pydantic -anyio==4.12.0 +anyio==4.12.1 # via httpx # via postgrid-python async-timeout==5.0.1 # via aiohttp attrs==25.4.0 # via aiohttp -certifi==2025.11.12 +certifi==2026.1.4 # via httpcore # via httpx distro==1.9.0 @@ -43,7 +43,7 @@ httpcore==1.0.9 httpx==0.28.1 # via httpx-aiohttp # via postgrid-python -httpx-aiohttp==0.1.9 +httpx-aiohttp==0.1.12 # via postgrid-python idna==3.11 # via anyio From 8a7fe146bf634f2fab49203e50eca29f43f3f1c3 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Wed, 11 Feb 2026 14:20:37 +0000 Subject: [PATCH 12/16] chore(internal): fix lint error on Python 3.14 --- src/postgrid/_utils/_compat.py | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/postgrid/_utils/_compat.py b/src/postgrid/_utils/_compat.py index dd70323..2c70b29 100644 --- a/src/postgrid/_utils/_compat.py +++ b/src/postgrid/_utils/_compat.py @@ -26,7 +26,7 @@ def is_union(tp: Optional[Type[Any]]) -> bool: else: import types - return tp is Union or tp is types.UnionType + return tp is Union or tp is types.UnionType # type: ignore[comparison-overlap] def is_typeddict(tp: Type[Any]) -> bool: From 0a364e28d4d8c4039925ead02608bcc66f6253f8 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 12 Feb 2026 16:50:59 +0000 Subject: [PATCH 13/16] chore: format all `api.md` files --- pyproject.toml | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/pyproject.toml b/pyproject.toml index b2bcfdf..542f91b 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -69,7 +69,7 @@ format = { chain = [ # run formatting again to fix any inconsistencies when imports are stripped "format:ruff", ]} -"format:docs" = "python scripts/utils/ruffen-docs.py README.md api.md" +"format:docs" = "bash -c 'python scripts/utils/ruffen-docs.py README.md $(find . -type f -name api.md)'" "format:ruff" = "ruff format" "lint" = { chain = [ From 961b979236edcd88d3c3f2b03f1033940b188bd2 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 19 Feb 2026 16:02:00 +0000 Subject: [PATCH 14/16] chore(internal): remove mock server code --- scripts/mock | 41 ----------------------------------------- scripts/test | 46 ---------------------------------------------- 2 files changed, 87 deletions(-) delete mode 100755 scripts/mock diff --git a/scripts/mock b/scripts/mock deleted file mode 100755 index 0b28f6e..0000000 --- a/scripts/mock +++ /dev/null @@ -1,41 +0,0 @@ -#!/usr/bin/env bash - -set -e - -cd "$(dirname "$0")/.." - -if [[ -n "$1" && "$1" != '--'* ]]; then - URL="$1" - shift -else - URL="$(grep 'openapi_spec_url' .stats.yml | cut -d' ' -f2)" -fi - -# Check if the URL is empty -if [ -z "$URL" ]; then - echo "Error: No OpenAPI spec path/url provided or found in .stats.yml" - exit 1 -fi - -echo "==> Starting mock server with URL ${URL}" - -# Run prism mock on the given spec -if [ "$1" == "--daemon" ]; then - npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" &> .prism.log & - - # Wait for server to come online - echo -n "Waiting for server" - while ! grep -q "✖ fatal\|Prism is listening" ".prism.log" ; do - echo -n "." - sleep 0.1 - done - - if grep -q "✖ fatal" ".prism.log"; then - cat .prism.log - exit 1 - fi - - echo -else - npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock "$URL" -fi diff --git a/scripts/test b/scripts/test index dbeda2d..39729d0 100755 --- a/scripts/test +++ b/scripts/test @@ -4,53 +4,7 @@ set -e cd "$(dirname "$0")/.." -RED='\033[0;31m' -GREEN='\033[0;32m' -YELLOW='\033[0;33m' -NC='\033[0m' # No Color -function prism_is_running() { - curl --silent "http://localhost:4010" >/dev/null 2>&1 -} - -kill_server_on_port() { - pids=$(lsof -t -i tcp:"$1" || echo "") - if [ "$pids" != "" ]; then - kill "$pids" - echo "Stopped $pids." - fi -} - -function is_overriding_api_base_url() { - [ -n "$TEST_API_BASE_URL" ] -} - -if ! is_overriding_api_base_url && ! prism_is_running ; then - # When we exit this script, make sure to kill the background mock server process - trap 'kill_server_on_port 4010' EXIT - - # Start the dev server - ./scripts/mock --daemon -fi - -if is_overriding_api_base_url ; then - echo -e "${GREEN}✔ Running tests against ${TEST_API_BASE_URL}${NC}" - echo -elif ! prism_is_running ; then - echo -e "${RED}ERROR:${NC} The test suite will not run without a mock Prism server" - echo -e "running against your OpenAPI spec." - echo - echo -e "To run the server, pass in the path or url of your OpenAPI" - echo -e "spec to the prism command:" - echo - echo -e " \$ ${YELLOW}npm exec --package=@stainless-api/prism-cli@5.15.0 -- prism mock path/to/your.openapi.yml${NC}" - echo - - exit 1 -else - echo -e "${GREEN}✔ Mock prism server is running with your OpenAPI spec${NC}" - echo -fi export DEFER_PYDANTIC_BUILD=false From 168a3b8c77755038a1fefd557d71ad49f753a360 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 19 Feb 2026 16:32:08 +0000 Subject: [PATCH 15/16] chore: update mock server docs --- CONTRIBUTING.md | 7 - .../print_mail/order_profiles/test_cheques.py | 88 ++++++------- .../print_mail/order_profiles/test_letters.py | 88 ++++++------- .../order_profiles/test_postcards.py | 88 ++++++------- .../order_profiles/test_self_mailers.py | 88 ++++++------- .../print_mail/reports/test_exports.py | 52 ++++---- .../print_mail/reports/test_samples.py | 20 +-- .../print_mail/test_bank_accounts.py | 96 +++++++------- .../print_mail/test_campaigns.py | 104 +++++++-------- .../api_resources/print_mail/test_cheques.py | 96 +++++++------- .../api_resources/print_mail/test_contacts.py | 80 +++++------ .../api_resources/print_mail/test_letters.py | 108 +++++++-------- .../print_mail/test_mailing_list_imports.py | 84 ++++++------ .../print_mail/test_mailing_lists.py | 104 +++++++-------- .../print_mail/test_postcards.py | 124 +++++++++--------- .../api_resources/print_mail/test_reports.py | 100 +++++++------- .../print_mail/test_self_mailers.py | 124 +++++++++--------- .../print_mail/test_sub_organizations.py | 68 +++++----- .../print_mail/test_templates.py | 84 ++++++------ .../test_address_verification.py | 32 ++--- .../test_intl_address_verification.py | 32 ++--- 21 files changed, 830 insertions(+), 837 deletions(-) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index 13075b3..8aaa2c3 100644 --- a/CONTRIBUTING.md +++ b/CONTRIBUTING.md @@ -85,13 +85,6 @@ $ pip install ./path-to-wheel-file.whl ## Running tests -Most tests require you to [set up a mock server](https://github.com/stoplightio/prism) against the OpenAPI spec to run the tests. - -```sh -# you will need npm installed -$ npx prism mock path/to/your/openapi.yml -``` - ```sh $ ./scripts/test ``` diff --git a/tests/api_resources/print_mail/order_profiles/test_cheques.py b/tests/api_resources/print_mail/order_profiles/test_cheques.py index 34f5ed4..5faf74b 100644 --- a/tests/api_resources/print_mail/order_profiles/test_cheques.py +++ b/tests/api_resources/print_mail/order_profiles/test_cheques.py @@ -22,7 +22,7 @@ class TestCheques: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: cheque = client.print_mail.order_profiles.cheques.create( @@ -31,7 +31,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: cheque = client.print_mail.order_profiles.cheques.create( @@ -51,7 +51,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.cheques.with_raw_response.create( @@ -64,7 +64,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.order_profiles.cheques.with_streaming_response.create( @@ -79,7 +79,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: cheque = client.print_mail.order_profiles.cheques.retrieve( @@ -87,7 +87,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_with_all_params(self, client: PostGrid) -> None: cheque = client.print_mail.order_profiles.cheques.retrieve( @@ -96,7 +96,7 @@ def test_method_retrieve_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.cheques.with_raw_response.retrieve( @@ -108,7 +108,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.order_profiles.cheques.with_streaming_response.retrieve( @@ -122,7 +122,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -130,7 +130,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: cheque = client.print_mail.order_profiles.cheques.update( @@ -140,7 +140,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: cheque = client.print_mail.order_profiles.cheques.update( @@ -161,7 +161,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.cheques.with_raw_response.update( @@ -175,7 +175,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.order_profiles.cheques.with_streaming_response.update( @@ -191,7 +191,7 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_update(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -201,13 +201,13 @@ def test_path_params_update(self, client: PostGrid) -> None: size="us_letter", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: cheque = client.print_mail.order_profiles.cheques.list() assert_matches_type(SyncSkipLimit[ChequeListResponse], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: cheque = client.print_mail.order_profiles.cheques.list( @@ -217,7 +217,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[ChequeListResponse], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.cheques.with_raw_response.list() @@ -227,7 +227,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(SyncSkipLimit[ChequeListResponse], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.order_profiles.cheques.with_streaming_response.list() as response: @@ -239,7 +239,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: cheque = client.print_mail.order_profiles.cheques.delete( @@ -247,7 +247,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(ChequeDeleteResponse, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.cheques.with_raw_response.delete( @@ -259,7 +259,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(ChequeDeleteResponse, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.order_profiles.cheques.with_streaming_response.delete( @@ -273,7 +273,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -287,7 +287,7 @@ class TestAsyncCheques: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.order_profiles.cheques.create( @@ -296,7 +296,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.order_profiles.cheques.create( @@ -316,7 +316,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.cheques.with_raw_response.create( @@ -329,7 +329,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: cheque = await response.parse() assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.cheques.with_streaming_response.create( @@ -344,7 +344,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.order_profiles.cheques.retrieve( @@ -352,7 +352,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_with_all_params(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.order_profiles.cheques.retrieve( @@ -361,7 +361,7 @@ async def test_method_retrieve_with_all_params(self, async_client: AsyncPostGrid ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.cheques.with_raw_response.retrieve( @@ -373,7 +373,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: cheque = await response.parse() assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.cheques.with_streaming_response.retrieve( @@ -387,7 +387,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -395,7 +395,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.order_profiles.cheques.update( @@ -405,7 +405,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.order_profiles.cheques.update( @@ -426,7 +426,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.cheques.with_raw_response.update( @@ -440,7 +440,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: cheque = await response.parse() assert_matches_type(ChequeProfile, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.cheques.with_streaming_response.update( @@ -456,7 +456,7 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -466,13 +466,13 @@ async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: size="us_letter", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.order_profiles.cheques.list() assert_matches_type(AsyncSkipLimit[ChequeListResponse], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.order_profiles.cheques.list( @@ -482,7 +482,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[ChequeListResponse], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.cheques.with_raw_response.list() @@ -492,7 +492,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: cheque = await response.parse() assert_matches_type(AsyncSkipLimit[ChequeListResponse], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.cheques.with_streaming_response.list() as response: @@ -504,7 +504,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.order_profiles.cheques.delete( @@ -512,7 +512,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ChequeDeleteResponse, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.cheques.with_raw_response.delete( @@ -524,7 +524,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: cheque = await response.parse() assert_matches_type(ChequeDeleteResponse, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.cheques.with_streaming_response.delete( @@ -538,7 +538,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/order_profiles/test_letters.py b/tests/api_resources/print_mail/order_profiles/test_letters.py index 31387d0..2929536 100644 --- a/tests/api_resources/print_mail/order_profiles/test_letters.py +++ b/tests/api_resources/print_mail/order_profiles/test_letters.py @@ -21,7 +21,7 @@ class TestLetters: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: letter = client.print_mail.order_profiles.letters.create( @@ -29,7 +29,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: letter = client.print_mail.order_profiles.letters.create( @@ -54,7 +54,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.letters.with_raw_response.create( @@ -66,7 +66,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.order_profiles.letters.with_streaming_response.create( @@ -80,7 +80,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: letter = client.print_mail.order_profiles.letters.retrieve( @@ -88,7 +88,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_with_all_params(self, client: PostGrid) -> None: letter = client.print_mail.order_profiles.letters.retrieve( @@ -97,7 +97,7 @@ def test_method_retrieve_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.letters.with_raw_response.retrieve( @@ -109,7 +109,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.order_profiles.letters.with_streaming_response.retrieve( @@ -123,7 +123,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -131,7 +131,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: letter = client.print_mail.order_profiles.letters.update( @@ -139,7 +139,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: letter = client.print_mail.order_profiles.letters.update( @@ -164,7 +164,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.letters.with_raw_response.update( @@ -176,7 +176,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.order_profiles.letters.with_streaming_response.update( @@ -190,7 +190,7 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_update(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -198,13 +198,13 @@ def test_path_params_update(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: letter = client.print_mail.order_profiles.letters.list() assert_matches_type(SyncSkipLimit[LetterProfile], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: letter = client.print_mail.order_profiles.letters.list( @@ -214,7 +214,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[LetterProfile], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.letters.with_raw_response.list() @@ -224,7 +224,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(SyncSkipLimit[LetterProfile], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.order_profiles.letters.with_streaming_response.list() as response: @@ -236,7 +236,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: letter = client.print_mail.order_profiles.letters.delete( @@ -244,7 +244,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(LetterDeleteResponse, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.letters.with_raw_response.delete( @@ -256,7 +256,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(LetterDeleteResponse, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.order_profiles.letters.with_streaming_response.delete( @@ -270,7 +270,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -284,7 +284,7 @@ class TestAsyncLetters: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.order_profiles.letters.create( @@ -292,7 +292,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.order_profiles.letters.create( @@ -317,7 +317,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.letters.with_raw_response.create( @@ -329,7 +329,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: letter = await response.parse() assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.letters.with_streaming_response.create( @@ -343,7 +343,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.order_profiles.letters.retrieve( @@ -351,7 +351,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_with_all_params(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.order_profiles.letters.retrieve( @@ -360,7 +360,7 @@ async def test_method_retrieve_with_all_params(self, async_client: AsyncPostGrid ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.letters.with_raw_response.retrieve( @@ -372,7 +372,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: letter = await response.parse() assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.letters.with_streaming_response.retrieve( @@ -386,7 +386,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -394,7 +394,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.order_profiles.letters.update( @@ -402,7 +402,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.order_profiles.letters.update( @@ -427,7 +427,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.letters.with_raw_response.update( @@ -439,7 +439,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: letter = await response.parse() assert_matches_type(LetterProfile, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.letters.with_streaming_response.update( @@ -453,7 +453,7 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -461,13 +461,13 @@ async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.order_profiles.letters.list() assert_matches_type(AsyncSkipLimit[LetterProfile], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.order_profiles.letters.list( @@ -477,7 +477,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[LetterProfile], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.letters.with_raw_response.list() @@ -487,7 +487,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: letter = await response.parse() assert_matches_type(AsyncSkipLimit[LetterProfile], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.letters.with_streaming_response.list() as response: @@ -499,7 +499,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.order_profiles.letters.delete( @@ -507,7 +507,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(LetterDeleteResponse, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.letters.with_raw_response.delete( @@ -519,7 +519,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: letter = await response.parse() assert_matches_type(LetterDeleteResponse, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.letters.with_streaming_response.delete( @@ -533,7 +533,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/order_profiles/test_postcards.py b/tests/api_resources/print_mail/order_profiles/test_postcards.py index 98e2862..e9172b7 100644 --- a/tests/api_resources/print_mail/order_profiles/test_postcards.py +++ b/tests/api_resources/print_mail/order_profiles/test_postcards.py @@ -21,7 +21,7 @@ class TestPostcards: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: postcard = client.print_mail.order_profiles.postcards.create( @@ -29,7 +29,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: postcard = client.print_mail.order_profiles.postcards.create( @@ -45,7 +45,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.postcards.with_raw_response.create( @@ -57,7 +57,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.order_profiles.postcards.with_streaming_response.create( @@ -71,7 +71,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: postcard = client.print_mail.order_profiles.postcards.retrieve( @@ -79,7 +79,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_with_all_params(self, client: PostGrid) -> None: postcard = client.print_mail.order_profiles.postcards.retrieve( @@ -88,7 +88,7 @@ def test_method_retrieve_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.postcards.with_raw_response.retrieve( @@ -100,7 +100,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.order_profiles.postcards.with_streaming_response.retrieve( @@ -114,7 +114,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -122,7 +122,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: postcard = client.print_mail.order_profiles.postcards.update( @@ -130,7 +130,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: postcard = client.print_mail.order_profiles.postcards.update( @@ -146,7 +146,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.postcards.with_raw_response.update( @@ -158,7 +158,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.order_profiles.postcards.with_streaming_response.update( @@ -172,7 +172,7 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_update(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -180,13 +180,13 @@ def test_path_params_update(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: postcard = client.print_mail.order_profiles.postcards.list() assert_matches_type(SyncSkipLimit[PostcardProfile], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: postcard = client.print_mail.order_profiles.postcards.list( @@ -196,7 +196,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[PostcardProfile], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.postcards.with_raw_response.list() @@ -206,7 +206,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(SyncSkipLimit[PostcardProfile], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.order_profiles.postcards.with_streaming_response.list() as response: @@ -218,7 +218,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: postcard = client.print_mail.order_profiles.postcards.delete( @@ -226,7 +226,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(PostcardDeleteResponse, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.postcards.with_raw_response.delete( @@ -238,7 +238,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(PostcardDeleteResponse, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.order_profiles.postcards.with_streaming_response.delete( @@ -252,7 +252,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -266,7 +266,7 @@ class TestAsyncPostcards: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.order_profiles.postcards.create( @@ -274,7 +274,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.order_profiles.postcards.create( @@ -290,7 +290,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.postcards.with_raw_response.create( @@ -302,7 +302,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: postcard = await response.parse() assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.postcards.with_streaming_response.create( @@ -316,7 +316,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.order_profiles.postcards.retrieve( @@ -324,7 +324,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_with_all_params(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.order_profiles.postcards.retrieve( @@ -333,7 +333,7 @@ async def test_method_retrieve_with_all_params(self, async_client: AsyncPostGrid ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.postcards.with_raw_response.retrieve( @@ -345,7 +345,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: postcard = await response.parse() assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.postcards.with_streaming_response.retrieve( @@ -359,7 +359,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -367,7 +367,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.order_profiles.postcards.update( @@ -375,7 +375,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.order_profiles.postcards.update( @@ -391,7 +391,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.postcards.with_raw_response.update( @@ -403,7 +403,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: postcard = await response.parse() assert_matches_type(PostcardProfile, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.postcards.with_streaming_response.update( @@ -417,7 +417,7 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -425,13 +425,13 @@ async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.order_profiles.postcards.list() assert_matches_type(AsyncSkipLimit[PostcardProfile], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.order_profiles.postcards.list( @@ -441,7 +441,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[PostcardProfile], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.postcards.with_raw_response.list() @@ -451,7 +451,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: postcard = await response.parse() assert_matches_type(AsyncSkipLimit[PostcardProfile], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.postcards.with_streaming_response.list() as response: @@ -463,7 +463,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.order_profiles.postcards.delete( @@ -471,7 +471,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(PostcardDeleteResponse, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.postcards.with_raw_response.delete( @@ -483,7 +483,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: postcard = await response.parse() assert_matches_type(PostcardDeleteResponse, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.postcards.with_streaming_response.delete( @@ -497,7 +497,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/order_profiles/test_self_mailers.py b/tests/api_resources/print_mail/order_profiles/test_self_mailers.py index 006acbf..e679be9 100644 --- a/tests/api_resources/print_mail/order_profiles/test_self_mailers.py +++ b/tests/api_resources/print_mail/order_profiles/test_self_mailers.py @@ -21,7 +21,7 @@ class TestSelfMailers: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: self_mailer = client.print_mail.order_profiles.self_mailers.create( @@ -29,7 +29,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: self_mailer = client.print_mail.order_profiles.self_mailers.create( @@ -45,7 +45,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.self_mailers.with_raw_response.create( @@ -57,7 +57,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.order_profiles.self_mailers.with_streaming_response.create( @@ -71,7 +71,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: self_mailer = client.print_mail.order_profiles.self_mailers.retrieve( @@ -79,7 +79,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_with_all_params(self, client: PostGrid) -> None: self_mailer = client.print_mail.order_profiles.self_mailers.retrieve( @@ -88,7 +88,7 @@ def test_method_retrieve_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.self_mailers.with_raw_response.retrieve( @@ -100,7 +100,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.order_profiles.self_mailers.with_streaming_response.retrieve( @@ -114,7 +114,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -122,7 +122,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: self_mailer = client.print_mail.order_profiles.self_mailers.update( @@ -131,7 +131,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: self_mailer = client.print_mail.order_profiles.self_mailers.update( @@ -148,7 +148,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.self_mailers.with_raw_response.update( @@ -161,7 +161,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.order_profiles.self_mailers.with_streaming_response.update( @@ -176,7 +176,7 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_update(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -185,13 +185,13 @@ def test_path_params_update(self, client: PostGrid) -> None: size="8.5x11_bifold", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: self_mailer = client.print_mail.order_profiles.self_mailers.list() assert_matches_type(SyncSkipLimit[SelfMailerProfile], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: self_mailer = client.print_mail.order_profiles.self_mailers.list( @@ -201,7 +201,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[SelfMailerProfile], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.self_mailers.with_raw_response.list() @@ -211,7 +211,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SyncSkipLimit[SelfMailerProfile], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.order_profiles.self_mailers.with_streaming_response.list() as response: @@ -223,7 +223,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: self_mailer = client.print_mail.order_profiles.self_mailers.delete( @@ -231,7 +231,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailerDeleteResponse, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.order_profiles.self_mailers.with_raw_response.delete( @@ -243,7 +243,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailerDeleteResponse, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.order_profiles.self_mailers.with_streaming_response.delete( @@ -257,7 +257,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -271,7 +271,7 @@ class TestAsyncSelfMailers: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.order_profiles.self_mailers.create( @@ -279,7 +279,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.order_profiles.self_mailers.create( @@ -295,7 +295,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.self_mailers.with_raw_response.create( @@ -307,7 +307,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: self_mailer = await response.parse() assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.self_mailers.with_streaming_response.create( @@ -321,7 +321,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.order_profiles.self_mailers.retrieve( @@ -329,7 +329,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_with_all_params(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.order_profiles.self_mailers.retrieve( @@ -338,7 +338,7 @@ async def test_method_retrieve_with_all_params(self, async_client: AsyncPostGrid ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.self_mailers.with_raw_response.retrieve( @@ -350,7 +350,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: self_mailer = await response.parse() assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.self_mailers.with_streaming_response.retrieve( @@ -364,7 +364,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -372,7 +372,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.order_profiles.self_mailers.update( @@ -381,7 +381,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.order_profiles.self_mailers.update( @@ -398,7 +398,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.self_mailers.with_raw_response.update( @@ -411,7 +411,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: self_mailer = await response.parse() assert_matches_type(SelfMailerProfile, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.self_mailers.with_streaming_response.update( @@ -426,7 +426,7 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -435,13 +435,13 @@ async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: size="8.5x11_bifold", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.order_profiles.self_mailers.list() assert_matches_type(AsyncSkipLimit[SelfMailerProfile], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.order_profiles.self_mailers.list( @@ -451,7 +451,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[SelfMailerProfile], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.self_mailers.with_raw_response.list() @@ -461,7 +461,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: self_mailer = await response.parse() assert_matches_type(AsyncSkipLimit[SelfMailerProfile], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.self_mailers.with_streaming_response.list() as response: @@ -473,7 +473,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.order_profiles.self_mailers.delete( @@ -481,7 +481,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SelfMailerDeleteResponse, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.order_profiles.self_mailers.with_raw_response.delete( @@ -493,7 +493,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: self_mailer = await response.parse() assert_matches_type(SelfMailerDeleteResponse, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.order_profiles.self_mailers.with_streaming_response.delete( @@ -507,7 +507,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/reports/test_exports.py b/tests/api_resources/print_mail/reports/test_exports.py index 2b22d9b..ee41c41 100644 --- a/tests/api_resources/print_mail/reports/test_exports.py +++ b/tests/api_resources/print_mail/reports/test_exports.py @@ -18,7 +18,7 @@ class TestExports: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: export = client.print_mail.reports.exports.create( @@ -26,7 +26,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: export = client.print_mail.reports.exports.create( @@ -37,7 +37,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.reports.exports.with_raw_response.create( @@ -49,7 +49,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: export = response.parse() assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.reports.exports.with_streaming_response.create( @@ -63,7 +63,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_create(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `report_id` but received ''"): @@ -71,7 +71,7 @@ def test_path_params_create(self, client: PostGrid) -> None: report_id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: export = client.print_mail.reports.exports.retrieve( @@ -80,7 +80,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.reports.exports.with_raw_response.retrieve( @@ -93,7 +93,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: export = response.parse() assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.reports.exports.with_streaming_response.retrieve( @@ -108,7 +108,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `report_id` but received ''"): @@ -123,7 +123,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: report_id="reportID", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: export = client.print_mail.reports.exports.delete( @@ -132,7 +132,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(DeletedResponse, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.reports.exports.with_raw_response.delete( @@ -145,7 +145,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: export = response.parse() assert_matches_type(DeletedResponse, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.reports.exports.with_streaming_response.delete( @@ -160,7 +160,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `report_id` but received ''"): @@ -181,7 +181,7 @@ class TestAsyncExports: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: export = await async_client.print_mail.reports.exports.create( @@ -189,7 +189,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: export = await async_client.print_mail.reports.exports.create( @@ -200,7 +200,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.exports.with_raw_response.create( @@ -212,7 +212,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: export = await response.parse() assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.exports.with_streaming_response.create( @@ -226,7 +226,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_create(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `report_id` but received ''"): @@ -234,7 +234,7 @@ async def test_path_params_create(self, async_client: AsyncPostGrid) -> None: report_id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: export = await async_client.print_mail.reports.exports.retrieve( @@ -243,7 +243,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.exports.with_raw_response.retrieve( @@ -256,7 +256,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: export = await response.parse() assert_matches_type(ReportExport, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.exports.with_streaming_response.retrieve( @@ -271,7 +271,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `report_id` but received ''"): @@ -286,7 +286,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: report_id="reportID", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: export = await async_client.print_mail.reports.exports.delete( @@ -295,7 +295,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(DeletedResponse, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.exports.with_raw_response.delete( @@ -308,7 +308,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: export = await response.parse() assert_matches_type(DeletedResponse, export, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.exports.with_streaming_response.delete( @@ -323,7 +323,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `report_id` but received ''"): diff --git a/tests/api_resources/print_mail/reports/test_samples.py b/tests/api_resources/print_mail/reports/test_samples.py index 50be716..d097260 100644 --- a/tests/api_resources/print_mail/reports/test_samples.py +++ b/tests/api_resources/print_mail/reports/test_samples.py @@ -17,7 +17,7 @@ class TestSamples: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: sample = client.print_mail.reports.samples.create( @@ -25,7 +25,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(ReportSample, sample, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: sample = client.print_mail.reports.samples.create( @@ -35,7 +35,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(ReportSample, sample, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.reports.samples.with_raw_response.create( @@ -47,7 +47,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: sample = response.parse() assert_matches_type(ReportSample, sample, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.reports.samples.with_streaming_response.create( @@ -61,7 +61,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_create(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -75,7 +75,7 @@ class TestAsyncSamples: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: sample = await async_client.print_mail.reports.samples.create( @@ -83,7 +83,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ReportSample, sample, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: sample = await async_client.print_mail.reports.samples.create( @@ -93,7 +93,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(ReportSample, sample, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.samples.with_raw_response.create( @@ -105,7 +105,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: sample = await response.parse() assert_matches_type(ReportSample, sample, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.samples.with_streaming_response.create( @@ -119,7 +119,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_create(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_bank_accounts.py b/tests/api_resources/print_mail/test_bank_accounts.py index 1cff59f..e531ad5 100644 --- a/tests/api_resources/print_mail/test_bank_accounts.py +++ b/tests/api_resources/print_mail/test_bank_accounts.py @@ -21,7 +21,7 @@ class TestBankAccounts: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_1(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.create( @@ -32,7 +32,7 @@ def test_method_create_overload_1(self, client: PostGrid) -> None: ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.create( @@ -51,7 +51,7 @@ def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> Non ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_1(self, client: PostGrid) -> None: response = client.print_mail.bank_accounts.with_raw_response.create( @@ -66,7 +66,7 @@ def test_raw_response_create_overload_1(self, client: PostGrid) -> None: bank_account = response.parse() assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: with client.print_mail.bank_accounts.with_streaming_response.create( @@ -83,7 +83,7 @@ def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_2(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.create( @@ -94,7 +94,7 @@ def test_method_create_overload_2(self, client: PostGrid) -> None: ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_2(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.create( @@ -113,7 +113,7 @@ def test_method_create_with_all_params_overload_2(self, client: PostGrid) -> Non ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_2(self, client: PostGrid) -> None: response = client.print_mail.bank_accounts.with_raw_response.create( @@ -128,7 +128,7 @@ def test_raw_response_create_overload_2(self, client: PostGrid) -> None: bank_account = response.parse() assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: with client.print_mail.bank_accounts.with_streaming_response.create( @@ -145,7 +145,7 @@ def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_3(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.create( @@ -156,7 +156,7 @@ def test_method_create_overload_3(self, client: PostGrid) -> None: ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_3(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.create( @@ -175,7 +175,7 @@ def test_method_create_with_all_params_overload_3(self, client: PostGrid) -> Non ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_3(self, client: PostGrid) -> None: response = client.print_mail.bank_accounts.with_raw_response.create( @@ -190,7 +190,7 @@ def test_raw_response_create_overload_3(self, client: PostGrid) -> None: bank_account = response.parse() assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_3(self, client: PostGrid) -> None: with client.print_mail.bank_accounts.with_streaming_response.create( @@ -207,7 +207,7 @@ def test_streaming_response_create_overload_3(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.retrieve( @@ -215,7 +215,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.bank_accounts.with_raw_response.retrieve( @@ -227,7 +227,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: bank_account = response.parse() assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.bank_accounts.with_streaming_response.retrieve( @@ -241,7 +241,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -249,13 +249,13 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.list() assert_matches_type(SyncSkipLimit[BankAccount], bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.list( @@ -265,7 +265,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[BankAccount], bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.bank_accounts.with_raw_response.list() @@ -275,7 +275,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: bank_account = response.parse() assert_matches_type(SyncSkipLimit[BankAccount], bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.bank_accounts.with_streaming_response.list() as response: @@ -287,7 +287,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: bank_account = client.print_mail.bank_accounts.delete( @@ -295,7 +295,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(BankAccountDeleteResponse, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.bank_accounts.with_raw_response.delete( @@ -307,7 +307,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: bank_account = response.parse() assert_matches_type(BankAccountDeleteResponse, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.bank_accounts.with_streaming_response.delete( @@ -321,7 +321,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -335,7 +335,7 @@ class TestAsyncBankAccounts: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.create( @@ -346,7 +346,7 @@ async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_1(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.create( @@ -365,7 +365,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.bank_accounts.with_raw_response.create( @@ -380,7 +380,7 @@ async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) bank_account = await response.parse() assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.bank_accounts.with_streaming_response.create( @@ -397,7 +397,7 @@ async def test_streaming_response_create_overload_1(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.create( @@ -408,7 +408,7 @@ async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_2(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.create( @@ -427,7 +427,7 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.bank_accounts.with_raw_response.create( @@ -442,7 +442,7 @@ async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) bank_account = await response.parse() assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.bank_accounts.with_streaming_response.create( @@ -459,7 +459,7 @@ async def test_streaming_response_create_overload_2(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_3(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.create( @@ -470,7 +470,7 @@ async def test_method_create_overload_3(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_3(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.create( @@ -489,7 +489,7 @@ async def test_method_create_with_all_params_overload_3(self, async_client: Asyn ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_3(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.bank_accounts.with_raw_response.create( @@ -504,7 +504,7 @@ async def test_raw_response_create_overload_3(self, async_client: AsyncPostGrid) bank_account = await response.parse() assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_3(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.bank_accounts.with_streaming_response.create( @@ -521,7 +521,7 @@ async def test_streaming_response_create_overload_3(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.retrieve( @@ -529,7 +529,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.bank_accounts.with_raw_response.retrieve( @@ -541,7 +541,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: bank_account = await response.parse() assert_matches_type(BankAccount, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.bank_accounts.with_streaming_response.retrieve( @@ -555,7 +555,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -563,13 +563,13 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.list() assert_matches_type(AsyncSkipLimit[BankAccount], bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.list( @@ -579,7 +579,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[BankAccount], bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.bank_accounts.with_raw_response.list() @@ -589,7 +589,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: bank_account = await response.parse() assert_matches_type(AsyncSkipLimit[BankAccount], bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.bank_accounts.with_streaming_response.list() as response: @@ -601,7 +601,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: bank_account = await async_client.print_mail.bank_accounts.delete( @@ -609,7 +609,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(BankAccountDeleteResponse, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.bank_accounts.with_raw_response.delete( @@ -621,7 +621,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: bank_account = await response.parse() assert_matches_type(BankAccountDeleteResponse, bank_account, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.bank_accounts.with_streaming_response.delete( @@ -635,7 +635,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_campaigns.py b/tests/api_resources/print_mail/test_campaigns.py index 1c88737..c65ae01 100644 --- a/tests/api_resources/print_mail/test_campaigns.py +++ b/tests/api_resources/print_mail/test_campaigns.py @@ -22,7 +22,7 @@ class TestCampaigns: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.create( @@ -30,7 +30,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.create( @@ -47,7 +47,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.campaigns.with_raw_response.create( @@ -59,7 +59,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: campaign = response.parse() assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.campaigns.with_streaming_response.create( @@ -73,7 +73,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.retrieve( @@ -81,7 +81,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.campaigns.with_raw_response.retrieve( @@ -93,7 +93,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: campaign = response.parse() assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.campaigns.with_streaming_response.retrieve( @@ -107,7 +107,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -115,7 +115,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.update( @@ -123,7 +123,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.update( @@ -139,7 +139,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.campaigns.with_raw_response.update( @@ -151,7 +151,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: campaign = response.parse() assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.campaigns.with_streaming_response.update( @@ -165,7 +165,7 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_update(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -173,13 +173,13 @@ def test_path_params_update(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.list() assert_matches_type(SyncSkipLimit[Campaign], campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.list( @@ -189,7 +189,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[Campaign], campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.campaigns.with_raw_response.list() @@ -199,7 +199,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: campaign = response.parse() assert_matches_type(SyncSkipLimit[Campaign], campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.campaigns.with_streaming_response.list() as response: @@ -211,7 +211,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.delete( @@ -219,7 +219,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(CampaignDeleteResponse, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.campaigns.with_raw_response.delete( @@ -231,7 +231,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: campaign = response.parse() assert_matches_type(CampaignDeleteResponse, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.campaigns.with_streaming_response.delete( @@ -245,7 +245,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -253,7 +253,7 @@ def test_path_params_delete(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_send(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.send( @@ -261,7 +261,7 @@ def test_method_send(self, client: PostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_send_with_all_params(self, client: PostGrid) -> None: campaign = client.print_mail.campaigns.send( @@ -270,7 +270,7 @@ def test_method_send_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_send(self, client: PostGrid) -> None: response = client.print_mail.campaigns.with_raw_response.send( @@ -282,7 +282,7 @@ def test_raw_response_send(self, client: PostGrid) -> None: campaign = response.parse() assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_send(self, client: PostGrid) -> None: with client.print_mail.campaigns.with_streaming_response.send( @@ -296,7 +296,7 @@ def test_streaming_response_send(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_send(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -310,7 +310,7 @@ class TestAsyncCampaigns: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.create( @@ -318,7 +318,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.create( @@ -335,7 +335,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.campaigns.with_raw_response.create( @@ -347,7 +347,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: campaign = await response.parse() assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.campaigns.with_streaming_response.create( @@ -361,7 +361,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.retrieve( @@ -369,7 +369,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.campaigns.with_raw_response.retrieve( @@ -381,7 +381,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: campaign = await response.parse() assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.campaigns.with_streaming_response.retrieve( @@ -395,7 +395,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -403,7 +403,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.update( @@ -411,7 +411,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.update( @@ -427,7 +427,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.campaigns.with_raw_response.update( @@ -439,7 +439,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: campaign = await response.parse() assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.campaigns.with_streaming_response.update( @@ -453,7 +453,7 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -461,13 +461,13 @@ async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.list() assert_matches_type(AsyncSkipLimit[Campaign], campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.list( @@ -477,7 +477,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[Campaign], campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.campaigns.with_raw_response.list() @@ -487,7 +487,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: campaign = await response.parse() assert_matches_type(AsyncSkipLimit[Campaign], campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.campaigns.with_streaming_response.list() as response: @@ -499,7 +499,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.delete( @@ -507,7 +507,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(CampaignDeleteResponse, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.campaigns.with_raw_response.delete( @@ -519,7 +519,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: campaign = await response.parse() assert_matches_type(CampaignDeleteResponse, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.campaigns.with_streaming_response.delete( @@ -533,7 +533,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -541,7 +541,7 @@ async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_send(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.send( @@ -549,7 +549,7 @@ async def test_method_send(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_send_with_all_params(self, async_client: AsyncPostGrid) -> None: campaign = await async_client.print_mail.campaigns.send( @@ -558,7 +558,7 @@ async def test_method_send_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_send(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.campaigns.with_raw_response.send( @@ -570,7 +570,7 @@ async def test_raw_response_send(self, async_client: AsyncPostGrid) -> None: campaign = await response.parse() assert_matches_type(Campaign, campaign, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_send(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.campaigns.with_streaming_response.send( @@ -584,7 +584,7 @@ async def test_streaming_response_send(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_send(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_cheques.py b/tests/api_resources/print_mail/test_cheques.py index 380a667..0be01a9 100644 --- a/tests/api_resources/print_mail/test_cheques.py +++ b/tests/api_resources/print_mail/test_cheques.py @@ -22,7 +22,7 @@ class TestCheques: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: cheque = client.print_mail.cheques.create( @@ -33,7 +33,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: cheque = client.print_mail.cheques.create( @@ -75,7 +75,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.cheques.with_raw_response.create( @@ -90,7 +90,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.cheques.with_streaming_response.create( @@ -107,7 +107,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: cheque = client.print_mail.cheques.retrieve( @@ -115,7 +115,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.cheques.with_raw_response.retrieve( @@ -127,7 +127,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.cheques.with_streaming_response.retrieve( @@ -141,7 +141,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -149,13 +149,13 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: cheque = client.print_mail.cheques.list() assert_matches_type(SyncSkipLimit[Cheque], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: cheque = client.print_mail.cheques.list( @@ -165,7 +165,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[Cheque], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.cheques.with_raw_response.list() @@ -175,7 +175,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(SyncSkipLimit[Cheque], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.cheques.with_streaming_response.list() as response: @@ -187,7 +187,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: cheque = client.print_mail.cheques.delete( @@ -195,7 +195,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.cheques.with_raw_response.delete( @@ -207,7 +207,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.cheques.with_streaming_response.delete( @@ -221,7 +221,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -229,7 +229,7 @@ def test_path_params_delete(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_url(self, client: PostGrid) -> None: cheque = client.print_mail.cheques.retrieve_url( @@ -237,7 +237,7 @@ def test_method_retrieve_url(self, client: PostGrid) -> None: ) assert_matches_type(ChequeRetrieveURLResponse, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve_url(self, client: PostGrid) -> None: response = client.print_mail.cheques.with_raw_response.retrieve_url( @@ -249,7 +249,7 @@ def test_raw_response_retrieve_url(self, client: PostGrid) -> None: cheque = response.parse() assert_matches_type(ChequeRetrieveURLResponse, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve_url(self, client: PostGrid) -> None: with client.print_mail.cheques.with_streaming_response.retrieve_url( @@ -263,7 +263,7 @@ def test_streaming_response_retrieve_url(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve_url(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -271,7 +271,7 @@ def test_path_params_retrieve_url(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_with_deposit_ready_pdf(self, client: PostGrid) -> None: cheque = client.print_mail.cheques.retrieve_with_deposit_ready_pdf( @@ -279,7 +279,7 @@ def test_method_retrieve_with_deposit_ready_pdf(self, client: PostGrid) -> None: ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve_with_deposit_ready_pdf(self, client: PostGrid) -> None: response = client.print_mail.cheques.with_raw_response.retrieve_with_deposit_ready_pdf( @@ -291,7 +291,7 @@ def test_raw_response_retrieve_with_deposit_ready_pdf(self, client: PostGrid) -> cheque = response.parse() assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve_with_deposit_ready_pdf(self, client: PostGrid) -> None: with client.print_mail.cheques.with_streaming_response.retrieve_with_deposit_ready_pdf( @@ -305,7 +305,7 @@ def test_streaming_response_retrieve_with_deposit_ready_pdf(self, client: PostGr assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve_with_deposit_ready_pdf(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -319,7 +319,7 @@ class TestAsyncCheques: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.cheques.create( @@ -330,7 +330,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.cheques.create( @@ -372,7 +372,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.cheques.with_raw_response.create( @@ -387,7 +387,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: cheque = await response.parse() assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.cheques.with_streaming_response.create( @@ -404,7 +404,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.cheques.retrieve( @@ -412,7 +412,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.cheques.with_raw_response.retrieve( @@ -424,7 +424,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: cheque = await response.parse() assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.cheques.with_streaming_response.retrieve( @@ -438,7 +438,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -446,13 +446,13 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.cheques.list() assert_matches_type(AsyncSkipLimit[Cheque], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.cheques.list( @@ -462,7 +462,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[Cheque], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.cheques.with_raw_response.list() @@ -472,7 +472,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: cheque = await response.parse() assert_matches_type(AsyncSkipLimit[Cheque], cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.cheques.with_streaming_response.list() as response: @@ -484,7 +484,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.cheques.delete( @@ -492,7 +492,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.cheques.with_raw_response.delete( @@ -504,7 +504,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: cheque = await response.parse() assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.cheques.with_streaming_response.delete( @@ -518,7 +518,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -526,7 +526,7 @@ async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_url(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.cheques.retrieve_url( @@ -534,7 +534,7 @@ async def test_method_retrieve_url(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ChequeRetrieveURLResponse, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve_url(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.cheques.with_raw_response.retrieve_url( @@ -546,7 +546,7 @@ async def test_raw_response_retrieve_url(self, async_client: AsyncPostGrid) -> N cheque = await response.parse() assert_matches_type(ChequeRetrieveURLResponse, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve_url(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.cheques.with_streaming_response.retrieve_url( @@ -560,7 +560,7 @@ async def test_streaming_response_retrieve_url(self, async_client: AsyncPostGrid assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve_url(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -568,7 +568,7 @@ async def test_path_params_retrieve_url(self, async_client: AsyncPostGrid) -> No "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_with_deposit_ready_pdf(self, async_client: AsyncPostGrid) -> None: cheque = await async_client.print_mail.cheques.retrieve_with_deposit_ready_pdf( @@ -576,7 +576,7 @@ async def test_method_retrieve_with_deposit_ready_pdf(self, async_client: AsyncP ) assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve_with_deposit_ready_pdf(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.cheques.with_raw_response.retrieve_with_deposit_ready_pdf( @@ -588,7 +588,7 @@ async def test_raw_response_retrieve_with_deposit_ready_pdf(self, async_client: cheque = await response.parse() assert_matches_type(Cheque, cheque, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve_with_deposit_ready_pdf(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.cheques.with_streaming_response.retrieve_with_deposit_ready_pdf( @@ -602,7 +602,7 @@ async def test_streaming_response_retrieve_with_deposit_ready_pdf(self, async_cl assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve_with_deposit_ready_pdf(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_contacts.py b/tests/api_resources/print_mail/test_contacts.py index 3b96c00..df470a5 100644 --- a/tests/api_resources/print_mail/test_contacts.py +++ b/tests/api_resources/print_mail/test_contacts.py @@ -18,7 +18,7 @@ class TestContacts: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_1(self, client: PostGrid) -> None: contact = client.print_mail.contacts.create( @@ -28,7 +28,7 @@ def test_method_create_overload_1(self, client: PostGrid) -> None: ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> None: contact = client.print_mail.contacts.create( @@ -51,7 +51,7 @@ def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> Non ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_1(self, client: PostGrid) -> None: response = client.print_mail.contacts.with_raw_response.create( @@ -65,7 +65,7 @@ def test_raw_response_create_overload_1(self, client: PostGrid) -> None: contact = response.parse() assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: with client.print_mail.contacts.with_streaming_response.create( @@ -81,7 +81,7 @@ def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_2(self, client: PostGrid) -> None: contact = client.print_mail.contacts.create( @@ -91,7 +91,7 @@ def test_method_create_overload_2(self, client: PostGrid) -> None: ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_2(self, client: PostGrid) -> None: contact = client.print_mail.contacts.create( @@ -114,7 +114,7 @@ def test_method_create_with_all_params_overload_2(self, client: PostGrid) -> Non ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_2(self, client: PostGrid) -> None: response = client.print_mail.contacts.with_raw_response.create( @@ -128,7 +128,7 @@ def test_raw_response_create_overload_2(self, client: PostGrid) -> None: contact = response.parse() assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: with client.print_mail.contacts.with_streaming_response.create( @@ -144,7 +144,7 @@ def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: contact = client.print_mail.contacts.retrieve( @@ -152,7 +152,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.contacts.with_raw_response.retrieve( @@ -164,7 +164,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: contact = response.parse() assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.contacts.with_streaming_response.retrieve( @@ -178,7 +178,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -186,13 +186,13 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: contact = client.print_mail.contacts.list() assert_matches_type(SyncSkipLimit[Contact], contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: contact = client.print_mail.contacts.list( @@ -202,7 +202,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[Contact], contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.contacts.with_raw_response.list() @@ -212,7 +212,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: contact = response.parse() assert_matches_type(SyncSkipLimit[Contact], contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.contacts.with_streaming_response.list() as response: @@ -224,7 +224,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: contact = client.print_mail.contacts.delete( @@ -232,7 +232,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(ContactDeleteResponse, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.contacts.with_raw_response.delete( @@ -244,7 +244,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: contact = response.parse() assert_matches_type(ContactDeleteResponse, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.contacts.with_streaming_response.delete( @@ -258,7 +258,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -272,7 +272,7 @@ class TestAsyncContacts: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> None: contact = await async_client.print_mail.contacts.create( @@ -282,7 +282,7 @@ async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_1(self, async_client: AsyncPostGrid) -> None: contact = await async_client.print_mail.contacts.create( @@ -305,7 +305,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.contacts.with_raw_response.create( @@ -319,7 +319,7 @@ async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) contact = await response.parse() assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.contacts.with_streaming_response.create( @@ -335,7 +335,7 @@ async def test_streaming_response_create_overload_1(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> None: contact = await async_client.print_mail.contacts.create( @@ -345,7 +345,7 @@ async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_2(self, async_client: AsyncPostGrid) -> None: contact = await async_client.print_mail.contacts.create( @@ -368,7 +368,7 @@ async def test_method_create_with_all_params_overload_2(self, async_client: Asyn ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.contacts.with_raw_response.create( @@ -382,7 +382,7 @@ async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) contact = await response.parse() assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.contacts.with_streaming_response.create( @@ -398,7 +398,7 @@ async def test_streaming_response_create_overload_2(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: contact = await async_client.print_mail.contacts.retrieve( @@ -406,7 +406,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.contacts.with_raw_response.retrieve( @@ -418,7 +418,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: contact = await response.parse() assert_matches_type(Contact, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.contacts.with_streaming_response.retrieve( @@ -432,7 +432,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -440,13 +440,13 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: contact = await async_client.print_mail.contacts.list() assert_matches_type(AsyncSkipLimit[Contact], contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: contact = await async_client.print_mail.contacts.list( @@ -456,7 +456,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[Contact], contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.contacts.with_raw_response.list() @@ -466,7 +466,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: contact = await response.parse() assert_matches_type(AsyncSkipLimit[Contact], contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.contacts.with_streaming_response.list() as response: @@ -478,7 +478,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: contact = await async_client.print_mail.contacts.delete( @@ -486,7 +486,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ContactDeleteResponse, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.contacts.with_raw_response.delete( @@ -498,7 +498,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: contact = await response.parse() assert_matches_type(ContactDeleteResponse, contact, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.contacts.with_streaming_response.delete( @@ -512,7 +512,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_letters.py b/tests/api_resources/print_mail/test_letters.py index 6341c56..1e80308 100644 --- a/tests/api_resources/print_mail/test_letters.py +++ b/tests/api_resources/print_mail/test_letters.py @@ -22,7 +22,7 @@ class TestLetters: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_1(self, client: PostGrid) -> None: letter = client.print_mail.letters.create( @@ -40,7 +40,7 @@ def test_method_create_overload_1(self, client: PostGrid) -> None: ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> None: letter = client.print_mail.letters.create( @@ -115,7 +115,7 @@ def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> Non ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_1(self, client: PostGrid) -> None: response = client.print_mail.letters.with_raw_response.create( @@ -137,7 +137,7 @@ def test_raw_response_create_overload_1(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: with client.print_mail.letters.with_streaming_response.create( @@ -161,7 +161,7 @@ def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_2(self, client: PostGrid) -> None: letter = client.print_mail.letters.create( @@ -169,7 +169,7 @@ def test_method_create_overload_2(self, client: PostGrid) -> None: ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_2(self, client: PostGrid) -> None: response = client.print_mail.letters.with_raw_response.create( @@ -181,7 +181,7 @@ def test_raw_response_create_overload_2(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: with client.print_mail.letters.with_streaming_response.create( @@ -195,7 +195,7 @@ def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_3(self, client: PostGrid) -> None: letter = client.print_mail.letters.create( @@ -213,7 +213,7 @@ def test_method_create_overload_3(self, client: PostGrid) -> None: ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_3(self, client: PostGrid) -> None: letter = client.print_mail.letters.create( @@ -288,7 +288,7 @@ def test_method_create_with_all_params_overload_3(self, client: PostGrid) -> Non ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_3(self, client: PostGrid) -> None: response = client.print_mail.letters.with_raw_response.create( @@ -310,7 +310,7 @@ def test_raw_response_create_overload_3(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_3(self, client: PostGrid) -> None: with client.print_mail.letters.with_streaming_response.create( @@ -334,7 +334,7 @@ def test_streaming_response_create_overload_3(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: letter = client.print_mail.letters.retrieve( @@ -342,7 +342,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.letters.with_raw_response.retrieve( @@ -354,7 +354,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.letters.with_streaming_response.retrieve( @@ -368,7 +368,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -376,13 +376,13 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: letter = client.print_mail.letters.list() assert_matches_type(SyncSkipLimit[Letter], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: letter = client.print_mail.letters.list( @@ -392,7 +392,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[Letter], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.letters.with_raw_response.list() @@ -402,7 +402,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(SyncSkipLimit[Letter], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.letters.with_streaming_response.list() as response: @@ -414,7 +414,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: letter = client.print_mail.letters.delete( @@ -422,7 +422,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.letters.with_raw_response.delete( @@ -434,7 +434,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.letters.with_streaming_response.delete( @@ -448,7 +448,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -456,7 +456,7 @@ def test_path_params_delete(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_url(self, client: PostGrid) -> None: letter = client.print_mail.letters.retrieve_url( @@ -464,7 +464,7 @@ def test_method_retrieve_url(self, client: PostGrid) -> None: ) assert_matches_type(LetterRetrieveURLResponse, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve_url(self, client: PostGrid) -> None: response = client.print_mail.letters.with_raw_response.retrieve_url( @@ -476,7 +476,7 @@ def test_raw_response_retrieve_url(self, client: PostGrid) -> None: letter = response.parse() assert_matches_type(LetterRetrieveURLResponse, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve_url(self, client: PostGrid) -> None: with client.print_mail.letters.with_streaming_response.retrieve_url( @@ -490,7 +490,7 @@ def test_streaming_response_retrieve_url(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve_url(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -504,7 +504,7 @@ class TestAsyncLetters: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.create( @@ -522,7 +522,7 @@ async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_1(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.create( @@ -597,7 +597,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.letters.with_raw_response.create( @@ -619,7 +619,7 @@ async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) letter = await response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.letters.with_streaming_response.create( @@ -643,7 +643,7 @@ async def test_streaming_response_create_overload_1(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.create( @@ -651,7 +651,7 @@ async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.letters.with_raw_response.create( @@ -663,7 +663,7 @@ async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) letter = await response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.letters.with_streaming_response.create( @@ -677,7 +677,7 @@ async def test_streaming_response_create_overload_2(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_3(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.create( @@ -695,7 +695,7 @@ async def test_method_create_overload_3(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_3(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.create( @@ -770,7 +770,7 @@ async def test_method_create_with_all_params_overload_3(self, async_client: Asyn ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_3(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.letters.with_raw_response.create( @@ -792,7 +792,7 @@ async def test_raw_response_create_overload_3(self, async_client: AsyncPostGrid) letter = await response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_3(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.letters.with_streaming_response.create( @@ -816,7 +816,7 @@ async def test_streaming_response_create_overload_3(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.retrieve( @@ -824,7 +824,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.letters.with_raw_response.retrieve( @@ -836,7 +836,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: letter = await response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.letters.with_streaming_response.retrieve( @@ -850,7 +850,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -858,13 +858,13 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.list() assert_matches_type(AsyncSkipLimit[Letter], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.list( @@ -874,7 +874,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[Letter], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.letters.with_raw_response.list() @@ -884,7 +884,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: letter = await response.parse() assert_matches_type(AsyncSkipLimit[Letter], letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.letters.with_streaming_response.list() as response: @@ -896,7 +896,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.delete( @@ -904,7 +904,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.letters.with_raw_response.delete( @@ -916,7 +916,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: letter = await response.parse() assert_matches_type(Letter, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.letters.with_streaming_response.delete( @@ -930,7 +930,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -938,7 +938,7 @@ async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_url(self, async_client: AsyncPostGrid) -> None: letter = await async_client.print_mail.letters.retrieve_url( @@ -946,7 +946,7 @@ async def test_method_retrieve_url(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(LetterRetrieveURLResponse, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve_url(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.letters.with_raw_response.retrieve_url( @@ -958,7 +958,7 @@ async def test_raw_response_retrieve_url(self, async_client: AsyncPostGrid) -> N letter = await response.parse() assert_matches_type(LetterRetrieveURLResponse, letter, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve_url(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.letters.with_streaming_response.retrieve_url( @@ -972,7 +972,7 @@ async def test_streaming_response_retrieve_url(self, async_client: AsyncPostGrid assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve_url(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_mailing_list_imports.py b/tests/api_resources/print_mail/test_mailing_list_imports.py index a110593..5e5b241 100644 --- a/tests/api_resources/print_mail/test_mailing_list_imports.py +++ b/tests/api_resources/print_mail/test_mailing_list_imports.py @@ -21,7 +21,7 @@ class TestMailingListImports: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: mailing_list_import = client.print_mail.mailing_list_imports.create( @@ -41,7 +41,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: mailing_list_import = client.print_mail.mailing_list_imports.create( @@ -67,7 +67,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.mailing_list_imports.with_raw_response.create( @@ -91,7 +91,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: mailing_list_import = response.parse() assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.mailing_list_imports.with_streaming_response.create( @@ -117,7 +117,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: mailing_list_import = client.print_mail.mailing_list_imports.retrieve( @@ -125,7 +125,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.mailing_list_imports.with_raw_response.retrieve( @@ -137,7 +137,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: mailing_list_import = response.parse() assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.mailing_list_imports.with_streaming_response.retrieve( @@ -151,7 +151,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -159,7 +159,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: mailing_list_import = client.print_mail.mailing_list_imports.update( @@ -167,7 +167,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: mailing_list_import = client.print_mail.mailing_list_imports.update( @@ -177,7 +177,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.mailing_list_imports.with_raw_response.update( @@ -189,7 +189,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: mailing_list_import = response.parse() assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.mailing_list_imports.with_streaming_response.update( @@ -203,7 +203,7 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_update(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -211,13 +211,13 @@ def test_path_params_update(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: mailing_list_import = client.print_mail.mailing_list_imports.list() assert_matches_type(SyncSkipLimit[MailingListImportResponse], mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: mailing_list_import = client.print_mail.mailing_list_imports.list( @@ -227,7 +227,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[MailingListImportResponse], mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.mailing_list_imports.with_raw_response.list() @@ -237,7 +237,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: mailing_list_import = response.parse() assert_matches_type(SyncSkipLimit[MailingListImportResponse], mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.mailing_list_imports.with_streaming_response.list() as response: @@ -249,7 +249,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: mailing_list_import = client.print_mail.mailing_list_imports.delete( @@ -257,7 +257,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(MailingListImportDeleteResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.mailing_list_imports.with_raw_response.delete( @@ -269,7 +269,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: mailing_list_import = response.parse() assert_matches_type(MailingListImportDeleteResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.mailing_list_imports.with_streaming_response.delete( @@ -283,7 +283,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -297,7 +297,7 @@ class TestAsyncMailingListImports: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await async_client.print_mail.mailing_list_imports.create( @@ -317,7 +317,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await async_client.print_mail.mailing_list_imports.create( @@ -343,7 +343,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_list_imports.with_raw_response.create( @@ -367,7 +367,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await response.parse() assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_list_imports.with_streaming_response.create( @@ -393,7 +393,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await async_client.print_mail.mailing_list_imports.retrieve( @@ -401,7 +401,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_list_imports.with_raw_response.retrieve( @@ -413,7 +413,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await response.parse() assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_list_imports.with_streaming_response.retrieve( @@ -427,7 +427,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -435,7 +435,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await async_client.print_mail.mailing_list_imports.update( @@ -443,7 +443,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await async_client.print_mail.mailing_list_imports.update( @@ -453,7 +453,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_list_imports.with_raw_response.update( @@ -465,7 +465,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await response.parse() assert_matches_type(MailingListImportResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_list_imports.with_streaming_response.update( @@ -479,7 +479,7 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -487,13 +487,13 @@ async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await async_client.print_mail.mailing_list_imports.list() assert_matches_type(AsyncSkipLimit[MailingListImportResponse], mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await async_client.print_mail.mailing_list_imports.list( @@ -503,7 +503,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[MailingListImportResponse], mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_list_imports.with_raw_response.list() @@ -513,7 +513,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await response.parse() assert_matches_type(AsyncSkipLimit[MailingListImportResponse], mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_list_imports.with_streaming_response.list() as response: @@ -525,7 +525,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await async_client.print_mail.mailing_list_imports.delete( @@ -533,7 +533,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(MailingListImportDeleteResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_list_imports.with_raw_response.delete( @@ -545,7 +545,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: mailing_list_import = await response.parse() assert_matches_type(MailingListImportDeleteResponse, mailing_list_import, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_list_imports.with_streaming_response.delete( @@ -559,7 +559,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_mailing_lists.py b/tests/api_resources/print_mail/test_mailing_lists.py index f01d576..297b5a0 100644 --- a/tests/api_resources/print_mail/test_mailing_lists.py +++ b/tests/api_resources/print_mail/test_mailing_lists.py @@ -22,13 +22,13 @@ class TestMailingLists: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.create() assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.create( @@ -38,7 +38,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.mailing_lists.with_raw_response.create() @@ -48,7 +48,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: mailing_list = response.parse() assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.mailing_lists.with_streaming_response.create() as response: @@ -60,7 +60,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.retrieve( @@ -68,7 +68,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.mailing_lists.with_raw_response.retrieve( @@ -80,7 +80,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: mailing_list = response.parse() assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.mailing_lists.with_streaming_response.retrieve( @@ -94,7 +94,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -102,7 +102,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.update( @@ -110,7 +110,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(MailingListUpdate, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.update( @@ -120,7 +120,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(MailingListUpdate, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.mailing_lists.with_raw_response.update( @@ -132,7 +132,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: mailing_list = response.parse() assert_matches_type(MailingListUpdate, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.mailing_lists.with_streaming_response.update( @@ -146,7 +146,7 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_update(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -154,13 +154,13 @@ def test_path_params_update(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.list() assert_matches_type(SyncSkipLimit[MailingList], mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.list( @@ -170,7 +170,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[MailingList], mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.mailing_lists.with_raw_response.list() @@ -180,7 +180,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: mailing_list = response.parse() assert_matches_type(SyncSkipLimit[MailingList], mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.mailing_lists.with_streaming_response.list() as response: @@ -192,7 +192,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.delete( @@ -200,7 +200,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(MailingListDeleteResponse, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.mailing_lists.with_raw_response.delete( @@ -212,7 +212,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: mailing_list = response.parse() assert_matches_type(MailingListDeleteResponse, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.mailing_lists.with_streaming_response.delete( @@ -226,7 +226,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -234,7 +234,7 @@ def test_path_params_delete(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_jobs(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.jobs( @@ -242,7 +242,7 @@ def test_method_jobs(self, client: PostGrid) -> None: ) assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_jobs_with_all_params(self, client: PostGrid) -> None: mailing_list = client.print_mail.mailing_lists.jobs( @@ -254,7 +254,7 @@ def test_method_jobs_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_jobs(self, client: PostGrid) -> None: response = client.print_mail.mailing_lists.with_raw_response.jobs( @@ -266,7 +266,7 @@ def test_raw_response_jobs(self, client: PostGrid) -> None: mailing_list = response.parse() assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_jobs(self, client: PostGrid) -> None: with client.print_mail.mailing_lists.with_streaming_response.jobs( @@ -280,7 +280,7 @@ def test_streaming_response_jobs(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_jobs(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -294,13 +294,13 @@ class TestAsyncMailingLists: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.create() assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.create( @@ -310,7 +310,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_lists.with_raw_response.create() @@ -320,7 +320,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: mailing_list = await response.parse() assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_lists.with_streaming_response.create() as response: @@ -332,7 +332,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.retrieve( @@ -340,7 +340,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_lists.with_raw_response.retrieve( @@ -352,7 +352,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: mailing_list = await response.parse() assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_lists.with_streaming_response.retrieve( @@ -366,7 +366,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -374,7 +374,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.update( @@ -382,7 +382,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(MailingListUpdate, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.update( @@ -392,7 +392,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(MailingListUpdate, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_lists.with_raw_response.update( @@ -404,7 +404,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: mailing_list = await response.parse() assert_matches_type(MailingListUpdate, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_lists.with_streaming_response.update( @@ -418,7 +418,7 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -426,13 +426,13 @@ async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.list() assert_matches_type(AsyncSkipLimit[MailingList], mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.list( @@ -442,7 +442,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[MailingList], mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_lists.with_raw_response.list() @@ -452,7 +452,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: mailing_list = await response.parse() assert_matches_type(AsyncSkipLimit[MailingList], mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_lists.with_streaming_response.list() as response: @@ -464,7 +464,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.delete( @@ -472,7 +472,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(MailingListDeleteResponse, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_lists.with_raw_response.delete( @@ -484,7 +484,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: mailing_list = await response.parse() assert_matches_type(MailingListDeleteResponse, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_lists.with_streaming_response.delete( @@ -498,7 +498,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -506,7 +506,7 @@ async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_jobs(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.jobs( @@ -514,7 +514,7 @@ async def test_method_jobs(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_jobs_with_all_params(self, async_client: AsyncPostGrid) -> None: mailing_list = await async_client.print_mail.mailing_lists.jobs( @@ -526,7 +526,7 @@ async def test_method_jobs_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_jobs(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.mailing_lists.with_raw_response.jobs( @@ -538,7 +538,7 @@ async def test_raw_response_jobs(self, async_client: AsyncPostGrid) -> None: mailing_list = await response.parse() assert_matches_type(MailingList, mailing_list, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_jobs(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.mailing_lists.with_streaming_response.jobs( @@ -552,7 +552,7 @@ async def test_streaming_response_jobs(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_jobs(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_postcards.py b/tests/api_resources/print_mail/test_postcards.py index b4d3690..dbae238 100644 --- a/tests/api_resources/print_mail/test_postcards.py +++ b/tests/api_resources/print_mail/test_postcards.py @@ -22,7 +22,7 @@ class TestPostcards: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_1(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.create( @@ -37,7 +37,7 @@ def test_method_create_overload_1(self, client: PostGrid) -> None: ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.create( @@ -88,7 +88,7 @@ def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> Non ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_1(self, client: PostGrid) -> None: response = client.print_mail.postcards.with_raw_response.create( @@ -107,7 +107,7 @@ def test_raw_response_create_overload_1(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: with client.print_mail.postcards.with_streaming_response.create( @@ -128,7 +128,7 @@ def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_2(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.create( @@ -137,7 +137,7 @@ def test_method_create_overload_2(self, client: PostGrid) -> None: ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_2(self, client: PostGrid) -> None: response = client.print_mail.postcards.with_raw_response.create( @@ -150,7 +150,7 @@ def test_raw_response_create_overload_2(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: with client.print_mail.postcards.with_streaming_response.create( @@ -165,7 +165,7 @@ def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_3(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.create( @@ -179,7 +179,7 @@ def test_method_create_overload_3(self, client: PostGrid) -> None: ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_3(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.create( @@ -229,7 +229,7 @@ def test_method_create_with_all_params_overload_3(self, client: PostGrid) -> Non ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_3(self, client: PostGrid) -> None: response = client.print_mail.postcards.with_raw_response.create( @@ -247,7 +247,7 @@ def test_raw_response_create_overload_3(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_3(self, client: PostGrid) -> None: with client.print_mail.postcards.with_streaming_response.create( @@ -267,7 +267,7 @@ def test_streaming_response_create_overload_3(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_4(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.create( @@ -281,7 +281,7 @@ def test_method_create_overload_4(self, client: PostGrid) -> None: ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_4(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.create( @@ -331,7 +331,7 @@ def test_method_create_with_all_params_overload_4(self, client: PostGrid) -> Non ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_4(self, client: PostGrid) -> None: response = client.print_mail.postcards.with_raw_response.create( @@ -349,7 +349,7 @@ def test_raw_response_create_overload_4(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_4(self, client: PostGrid) -> None: with client.print_mail.postcards.with_streaming_response.create( @@ -369,7 +369,7 @@ def test_streaming_response_create_overload_4(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.retrieve( @@ -377,7 +377,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.postcards.with_raw_response.retrieve( @@ -389,7 +389,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.postcards.with_streaming_response.retrieve( @@ -403,7 +403,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -411,13 +411,13 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.list() assert_matches_type(SyncSkipLimit[Postcard], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.list( @@ -427,7 +427,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[Postcard], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.postcards.with_raw_response.list() @@ -437,7 +437,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(SyncSkipLimit[Postcard], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.postcards.with_streaming_response.list() as response: @@ -449,7 +449,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.delete( @@ -457,7 +457,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.postcards.with_raw_response.delete( @@ -469,7 +469,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.postcards.with_streaming_response.delete( @@ -483,7 +483,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -491,7 +491,7 @@ def test_path_params_delete(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_url(self, client: PostGrid) -> None: postcard = client.print_mail.postcards.retrieve_url( @@ -499,7 +499,7 @@ def test_method_retrieve_url(self, client: PostGrid) -> None: ) assert_matches_type(PostcardRetrieveURLResponse, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve_url(self, client: PostGrid) -> None: response = client.print_mail.postcards.with_raw_response.retrieve_url( @@ -511,7 +511,7 @@ def test_raw_response_retrieve_url(self, client: PostGrid) -> None: postcard = response.parse() assert_matches_type(PostcardRetrieveURLResponse, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve_url(self, client: PostGrid) -> None: with client.print_mail.postcards.with_streaming_response.retrieve_url( @@ -525,7 +525,7 @@ def test_streaming_response_retrieve_url(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve_url(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -539,7 +539,7 @@ class TestAsyncPostcards: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.create( @@ -554,7 +554,7 @@ async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_1(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.create( @@ -605,7 +605,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.postcards.with_raw_response.create( @@ -624,7 +624,7 @@ async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) postcard = await response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.postcards.with_streaming_response.create( @@ -645,7 +645,7 @@ async def test_streaming_response_create_overload_1(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.create( @@ -654,7 +654,7 @@ async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.postcards.with_raw_response.create( @@ -667,7 +667,7 @@ async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) postcard = await response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.postcards.with_streaming_response.create( @@ -682,7 +682,7 @@ async def test_streaming_response_create_overload_2(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_3(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.create( @@ -696,7 +696,7 @@ async def test_method_create_overload_3(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_3(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.create( @@ -746,7 +746,7 @@ async def test_method_create_with_all_params_overload_3(self, async_client: Asyn ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_3(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.postcards.with_raw_response.create( @@ -764,7 +764,7 @@ async def test_raw_response_create_overload_3(self, async_client: AsyncPostGrid) postcard = await response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_3(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.postcards.with_streaming_response.create( @@ -784,7 +784,7 @@ async def test_streaming_response_create_overload_3(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_4(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.create( @@ -798,7 +798,7 @@ async def test_method_create_overload_4(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_4(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.create( @@ -848,7 +848,7 @@ async def test_method_create_with_all_params_overload_4(self, async_client: Asyn ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_4(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.postcards.with_raw_response.create( @@ -866,7 +866,7 @@ async def test_raw_response_create_overload_4(self, async_client: AsyncPostGrid) postcard = await response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_4(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.postcards.with_streaming_response.create( @@ -886,7 +886,7 @@ async def test_streaming_response_create_overload_4(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.retrieve( @@ -894,7 +894,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.postcards.with_raw_response.retrieve( @@ -906,7 +906,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: postcard = await response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.postcards.with_streaming_response.retrieve( @@ -920,7 +920,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -928,13 +928,13 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.list() assert_matches_type(AsyncSkipLimit[Postcard], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.list( @@ -944,7 +944,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[Postcard], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.postcards.with_raw_response.list() @@ -954,7 +954,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: postcard = await response.parse() assert_matches_type(AsyncSkipLimit[Postcard], postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.postcards.with_streaming_response.list() as response: @@ -966,7 +966,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.delete( @@ -974,7 +974,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.postcards.with_raw_response.delete( @@ -986,7 +986,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: postcard = await response.parse() assert_matches_type(Postcard, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.postcards.with_streaming_response.delete( @@ -1000,7 +1000,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -1008,7 +1008,7 @@ async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_url(self, async_client: AsyncPostGrid) -> None: postcard = await async_client.print_mail.postcards.retrieve_url( @@ -1016,7 +1016,7 @@ async def test_method_retrieve_url(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(PostcardRetrieveURLResponse, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve_url(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.postcards.with_raw_response.retrieve_url( @@ -1028,7 +1028,7 @@ async def test_raw_response_retrieve_url(self, async_client: AsyncPostGrid) -> N postcard = await response.parse() assert_matches_type(PostcardRetrieveURLResponse, postcard, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve_url(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.postcards.with_streaming_response.retrieve_url( @@ -1042,7 +1042,7 @@ async def test_streaming_response_retrieve_url(self, async_client: AsyncPostGrid assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve_url(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_reports.py b/tests/api_resources/print_mail/test_reports.py index 9a51971..6242004 100644 --- a/tests/api_resources/print_mail/test_reports.py +++ b/tests/api_resources/print_mail/test_reports.py @@ -22,7 +22,7 @@ class TestReports: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: report = client.print_mail.reports.create( @@ -30,7 +30,7 @@ def test_method_create(self, client: PostGrid) -> None: ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: report = client.print_mail.reports.create( @@ -40,7 +40,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.reports.with_raw_response.create( @@ -52,7 +52,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: report = response.parse() assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.reports.with_streaming_response.create( @@ -66,7 +66,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: report = client.print_mail.reports.retrieve( @@ -74,7 +74,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.reports.with_raw_response.retrieve( @@ -86,7 +86,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: report = response.parse() assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.reports.with_streaming_response.retrieve( @@ -100,7 +100,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -108,7 +108,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: report = client.print_mail.reports.update( @@ -116,7 +116,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: report = client.print_mail.reports.update( @@ -127,7 +127,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.reports.with_raw_response.update( @@ -139,7 +139,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: report = response.parse() assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.reports.with_streaming_response.update( @@ -153,7 +153,7 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_update(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -161,13 +161,13 @@ def test_path_params_update(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: report = client.print_mail.reports.list() assert_matches_type(SyncSkipLimit[Report], report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: report = client.print_mail.reports.list( @@ -177,7 +177,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[Report], report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.reports.with_raw_response.list() @@ -187,7 +187,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: report = response.parse() assert_matches_type(SyncSkipLimit[Report], report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.reports.with_streaming_response.list() as response: @@ -199,7 +199,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: report = client.print_mail.reports.delete( @@ -207,7 +207,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(DeletedResponse, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.reports.with_raw_response.delete( @@ -219,7 +219,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: report = response.parse() assert_matches_type(DeletedResponse, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.reports.with_streaming_response.delete( @@ -233,7 +233,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -241,7 +241,7 @@ def test_path_params_delete(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_sample(self, client: PostGrid) -> None: report = client.print_mail.reports.sample( @@ -249,7 +249,7 @@ def test_method_sample(self, client: PostGrid) -> None: ) assert_matches_type(ReportSample, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_sample_with_all_params(self, client: PostGrid) -> None: report = client.print_mail.reports.sample( @@ -259,7 +259,7 @@ def test_method_sample_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(ReportSample, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_sample(self, client: PostGrid) -> None: response = client.print_mail.reports.with_raw_response.sample( @@ -271,7 +271,7 @@ def test_raw_response_sample(self, client: PostGrid) -> None: report = response.parse() assert_matches_type(ReportSample, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_sample(self, client: PostGrid) -> None: with client.print_mail.reports.with_streaming_response.sample( @@ -291,7 +291,7 @@ class TestAsyncReports: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.create( @@ -299,7 +299,7 @@ async def test_method_create(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.create( @@ -309,7 +309,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.with_raw_response.create( @@ -321,7 +321,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: report = await response.parse() assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.with_streaming_response.create( @@ -335,7 +335,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.retrieve( @@ -343,7 +343,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.with_raw_response.retrieve( @@ -355,7 +355,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: report = await response.parse() assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.with_streaming_response.retrieve( @@ -369,7 +369,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -377,7 +377,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.update( @@ -385,7 +385,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.update( @@ -396,7 +396,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.with_raw_response.update( @@ -408,7 +408,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: report = await response.parse() assert_matches_type(Report, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.with_streaming_response.update( @@ -422,7 +422,7 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -430,13 +430,13 @@ async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.list() assert_matches_type(AsyncSkipLimit[Report], report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.list( @@ -446,7 +446,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[Report], report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.with_raw_response.list() @@ -456,7 +456,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: report = await response.parse() assert_matches_type(AsyncSkipLimit[Report], report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.with_streaming_response.list() as response: @@ -468,7 +468,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.delete( @@ -476,7 +476,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(DeletedResponse, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.with_raw_response.delete( @@ -488,7 +488,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: report = await response.parse() assert_matches_type(DeletedResponse, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.with_streaming_response.delete( @@ -502,7 +502,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -510,7 +510,7 @@ async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_sample(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.sample( @@ -518,7 +518,7 @@ async def test_method_sample(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(ReportSample, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_sample_with_all_params(self, async_client: AsyncPostGrid) -> None: report = await async_client.print_mail.reports.sample( @@ -528,7 +528,7 @@ async def test_method_sample_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(ReportSample, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_sample(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.reports.with_raw_response.sample( @@ -540,7 +540,7 @@ async def test_raw_response_sample(self, async_client: AsyncPostGrid) -> None: report = await response.parse() assert_matches_type(ReportSample, report, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_sample(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.reports.with_streaming_response.sample( diff --git a/tests/api_resources/print_mail/test_self_mailers.py b/tests/api_resources/print_mail/test_self_mailers.py index 2e400f3..d3ef9cb 100644 --- a/tests/api_resources/print_mail/test_self_mailers.py +++ b/tests/api_resources/print_mail/test_self_mailers.py @@ -22,7 +22,7 @@ class TestSelfMailers: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_1(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.create( @@ -42,7 +42,7 @@ def test_method_create_overload_1(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.create( @@ -93,7 +93,7 @@ def test_method_create_with_all_params_overload_1(self, client: PostGrid) -> Non ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_1(self, client: PostGrid) -> None: response = client.print_mail.self_mailers.with_raw_response.create( @@ -117,7 +117,7 @@ def test_raw_response_create_overload_1(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: with client.print_mail.self_mailers.with_streaming_response.create( @@ -143,7 +143,7 @@ def test_streaming_response_create_overload_1(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_2(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.create( @@ -152,7 +152,7 @@ def test_method_create_overload_2(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_2(self, client: PostGrid) -> None: response = client.print_mail.self_mailers.with_raw_response.create( @@ -165,7 +165,7 @@ def test_raw_response_create_overload_2(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: with client.print_mail.self_mailers.with_streaming_response.create( @@ -180,7 +180,7 @@ def test_streaming_response_create_overload_2(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_3(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.create( @@ -199,7 +199,7 @@ def test_method_create_overload_3(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_3(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.create( @@ -249,7 +249,7 @@ def test_method_create_with_all_params_overload_3(self, client: PostGrid) -> Non ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_3(self, client: PostGrid) -> None: response = client.print_mail.self_mailers.with_raw_response.create( @@ -272,7 +272,7 @@ def test_raw_response_create_overload_3(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_3(self, client: PostGrid) -> None: with client.print_mail.self_mailers.with_streaming_response.create( @@ -297,7 +297,7 @@ def test_streaming_response_create_overload_3(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_overload_4(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.create( @@ -316,7 +316,7 @@ def test_method_create_overload_4(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params_overload_4(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.create( @@ -366,7 +366,7 @@ def test_method_create_with_all_params_overload_4(self, client: PostGrid) -> Non ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create_overload_4(self, client: PostGrid) -> None: response = client.print_mail.self_mailers.with_raw_response.create( @@ -389,7 +389,7 @@ def test_raw_response_create_overload_4(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create_overload_4(self, client: PostGrid) -> None: with client.print_mail.self_mailers.with_streaming_response.create( @@ -414,7 +414,7 @@ def test_streaming_response_create_overload_4(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.retrieve( @@ -422,7 +422,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.self_mailers.with_raw_response.retrieve( @@ -434,7 +434,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.self_mailers.with_streaming_response.retrieve( @@ -448,7 +448,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -456,13 +456,13 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.list() assert_matches_type(SyncSkipLimit[SelfMailer], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.list( @@ -472,7 +472,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[SelfMailer], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.self_mailers.with_raw_response.list() @@ -482,7 +482,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SyncSkipLimit[SelfMailer], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.self_mailers.with_streaming_response.list() as response: @@ -494,7 +494,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.delete( @@ -502,7 +502,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.self_mailers.with_raw_response.delete( @@ -514,7 +514,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.self_mailers.with_streaming_response.delete( @@ -528,7 +528,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -536,7 +536,7 @@ def test_path_params_delete(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_url(self, client: PostGrid) -> None: self_mailer = client.print_mail.self_mailers.retrieve_url( @@ -544,7 +544,7 @@ def test_method_retrieve_url(self, client: PostGrid) -> None: ) assert_matches_type(SelfMailerRetrieveURLResponse, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve_url(self, client: PostGrid) -> None: response = client.print_mail.self_mailers.with_raw_response.retrieve_url( @@ -556,7 +556,7 @@ def test_raw_response_retrieve_url(self, client: PostGrid) -> None: self_mailer = response.parse() assert_matches_type(SelfMailerRetrieveURLResponse, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve_url(self, client: PostGrid) -> None: with client.print_mail.self_mailers.with_streaming_response.retrieve_url( @@ -570,7 +570,7 @@ def test_streaming_response_retrieve_url(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve_url(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -584,7 +584,7 @@ class TestAsyncSelfMailers: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.create( @@ -604,7 +604,7 @@ async def test_method_create_overload_1(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_1(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.create( @@ -655,7 +655,7 @@ async def test_method_create_with_all_params_overload_1(self, async_client: Asyn ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.self_mailers.with_raw_response.create( @@ -679,7 +679,7 @@ async def test_raw_response_create_overload_1(self, async_client: AsyncPostGrid) self_mailer = await response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_1(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.self_mailers.with_streaming_response.create( @@ -705,7 +705,7 @@ async def test_streaming_response_create_overload_1(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.create( @@ -714,7 +714,7 @@ async def test_method_create_overload_2(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.self_mailers.with_raw_response.create( @@ -727,7 +727,7 @@ async def test_raw_response_create_overload_2(self, async_client: AsyncPostGrid) self_mailer = await response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_2(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.self_mailers.with_streaming_response.create( @@ -742,7 +742,7 @@ async def test_streaming_response_create_overload_2(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_3(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.create( @@ -761,7 +761,7 @@ async def test_method_create_overload_3(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_3(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.create( @@ -811,7 +811,7 @@ async def test_method_create_with_all_params_overload_3(self, async_client: Asyn ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_3(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.self_mailers.with_raw_response.create( @@ -834,7 +834,7 @@ async def test_raw_response_create_overload_3(self, async_client: AsyncPostGrid) self_mailer = await response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_3(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.self_mailers.with_streaming_response.create( @@ -859,7 +859,7 @@ async def test_streaming_response_create_overload_3(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_overload_4(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.create( @@ -878,7 +878,7 @@ async def test_method_create_overload_4(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params_overload_4(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.create( @@ -928,7 +928,7 @@ async def test_method_create_with_all_params_overload_4(self, async_client: Asyn ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create_overload_4(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.self_mailers.with_raw_response.create( @@ -951,7 +951,7 @@ async def test_raw_response_create_overload_4(self, async_client: AsyncPostGrid) self_mailer = await response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create_overload_4(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.self_mailers.with_streaming_response.create( @@ -976,7 +976,7 @@ async def test_streaming_response_create_overload_4(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.retrieve( @@ -984,7 +984,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.self_mailers.with_raw_response.retrieve( @@ -996,7 +996,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: self_mailer = await response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.self_mailers.with_streaming_response.retrieve( @@ -1010,7 +1010,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -1018,13 +1018,13 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.list() assert_matches_type(AsyncSkipLimit[SelfMailer], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.list( @@ -1034,7 +1034,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[SelfMailer], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.self_mailers.with_raw_response.list() @@ -1044,7 +1044,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: self_mailer = await response.parse() assert_matches_type(AsyncSkipLimit[SelfMailer], self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.self_mailers.with_streaming_response.list() as response: @@ -1056,7 +1056,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.delete( @@ -1064,7 +1064,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.self_mailers.with_raw_response.delete( @@ -1076,7 +1076,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: self_mailer = await response.parse() assert_matches_type(SelfMailer, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.self_mailers.with_streaming_response.delete( @@ -1090,7 +1090,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -1098,7 +1098,7 @@ async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_url(self, async_client: AsyncPostGrid) -> None: self_mailer = await async_client.print_mail.self_mailers.retrieve_url( @@ -1106,7 +1106,7 @@ async def test_method_retrieve_url(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SelfMailerRetrieveURLResponse, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve_url(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.self_mailers.with_raw_response.retrieve_url( @@ -1118,7 +1118,7 @@ async def test_raw_response_retrieve_url(self, async_client: AsyncPostGrid) -> N self_mailer = await response.parse() assert_matches_type(SelfMailerRetrieveURLResponse, self_mailer, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve_url(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.self_mailers.with_streaming_response.retrieve_url( @@ -1132,7 +1132,7 @@ async def test_streaming_response_retrieve_url(self, async_client: AsyncPostGrid assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve_url(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_sub_organizations.py b/tests/api_resources/print_mail/test_sub_organizations.py index 53726d9..8f4ef5b 100644 --- a/tests/api_resources/print_mail/test_sub_organizations.py +++ b/tests/api_resources/print_mail/test_sub_organizations.py @@ -22,7 +22,7 @@ class TestSubOrganizations: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: sub_organization = client.print_mail.sub_organizations.retrieve( @@ -30,7 +30,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(SubOrganization, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.sub_organizations.with_raw_response.retrieve( @@ -42,7 +42,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: sub_organization = response.parse() assert_matches_type(SubOrganization, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.sub_organizations.with_streaming_response.retrieve( @@ -56,7 +56,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -64,7 +64,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: sub_organization = client.print_mail.sub_organizations.update( @@ -76,7 +76,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(SubOrganizationUpdateResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: sub_organization = client.print_mail.sub_organizations.update( @@ -89,7 +89,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SubOrganizationUpdateResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.sub_organizations.with_raw_response.update( @@ -105,7 +105,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: sub_organization = response.parse() assert_matches_type(SubOrganizationUpdateResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.sub_organizations.with_streaming_response.update( @@ -123,13 +123,13 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: sub_organization = client.print_mail.sub_organizations.list() assert_matches_type(SyncSkipLimit[SubOrganization], sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: sub_organization = client.print_mail.sub_organizations.list( @@ -139,7 +139,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[SubOrganization], sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.sub_organizations.with_raw_response.list() @@ -149,7 +149,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: sub_organization = response.parse() assert_matches_type(SyncSkipLimit[SubOrganization], sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.sub_organizations.with_streaming_response.list() as response: @@ -161,7 +161,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_users(self, client: PostGrid) -> None: sub_organization = client.print_mail.sub_organizations.retrieve_users( @@ -169,7 +169,7 @@ def test_method_retrieve_users(self, client: PostGrid) -> None: ) assert_matches_type(SubOrganizationRetrieveUsersResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_users_with_all_params(self, client: PostGrid) -> None: sub_organization = client.print_mail.sub_organizations.retrieve_users( @@ -180,7 +180,7 @@ def test_method_retrieve_users_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SubOrganizationRetrieveUsersResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve_users(self, client: PostGrid) -> None: response = client.print_mail.sub_organizations.with_raw_response.retrieve_users( @@ -192,7 +192,7 @@ def test_raw_response_retrieve_users(self, client: PostGrid) -> None: sub_organization = response.parse() assert_matches_type(SubOrganizationRetrieveUsersResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve_users(self, client: PostGrid) -> None: with client.print_mail.sub_organizations.with_streaming_response.retrieve_users( @@ -206,7 +206,7 @@ def test_streaming_response_retrieve_users(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve_users(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -220,7 +220,7 @@ class TestAsyncSubOrganizations: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: sub_organization = await async_client.print_mail.sub_organizations.retrieve( @@ -228,7 +228,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SubOrganization, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.sub_organizations.with_raw_response.retrieve( @@ -240,7 +240,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: sub_organization = await response.parse() assert_matches_type(SubOrganization, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.sub_organizations.with_streaming_response.retrieve( @@ -254,7 +254,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -262,7 +262,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: sub_organization = await async_client.print_mail.sub_organizations.update( @@ -274,7 +274,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SubOrganizationUpdateResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: sub_organization = await async_client.print_mail.sub_organizations.update( @@ -287,7 +287,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(SubOrganizationUpdateResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.sub_organizations.with_raw_response.update( @@ -303,7 +303,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: sub_organization = await response.parse() assert_matches_type(SubOrganizationUpdateResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.sub_organizations.with_streaming_response.update( @@ -321,13 +321,13 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: sub_organization = await async_client.print_mail.sub_organizations.list() assert_matches_type(AsyncSkipLimit[SubOrganization], sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: sub_organization = await async_client.print_mail.sub_organizations.list( @@ -337,7 +337,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[SubOrganization], sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.sub_organizations.with_raw_response.list() @@ -347,7 +347,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: sub_organization = await response.parse() assert_matches_type(AsyncSkipLimit[SubOrganization], sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.sub_organizations.with_streaming_response.list() as response: @@ -359,7 +359,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_users(self, async_client: AsyncPostGrid) -> None: sub_organization = await async_client.print_mail.sub_organizations.retrieve_users( @@ -367,7 +367,7 @@ async def test_method_retrieve_users(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(SubOrganizationRetrieveUsersResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_users_with_all_params(self, async_client: AsyncPostGrid) -> None: sub_organization = await async_client.print_mail.sub_organizations.retrieve_users( @@ -378,7 +378,7 @@ async def test_method_retrieve_users_with_all_params(self, async_client: AsyncPo ) assert_matches_type(SubOrganizationRetrieveUsersResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve_users(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.sub_organizations.with_raw_response.retrieve_users( @@ -390,7 +390,7 @@ async def test_raw_response_retrieve_users(self, async_client: AsyncPostGrid) -> sub_organization = await response.parse() assert_matches_type(SubOrganizationRetrieveUsersResponse, sub_organization, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve_users(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.sub_organizations.with_streaming_response.retrieve_users( @@ -404,7 +404,7 @@ async def test_streaming_response_retrieve_users(self, async_client: AsyncPostGr assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve_users(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/print_mail/test_templates.py b/tests/api_resources/print_mail/test_templates.py index 858c2fd..2e36687 100644 --- a/tests/api_resources/print_mail/test_templates.py +++ b/tests/api_resources/print_mail/test_templates.py @@ -21,13 +21,13 @@ class TestTemplates: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create(self, client: PostGrid) -> None: template = client.print_mail.templates.create() assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_create_with_all_params(self, client: PostGrid) -> None: template = client.print_mail.templates.create( @@ -37,7 +37,7 @@ def test_method_create_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_create(self, client: PostGrid) -> None: response = client.print_mail.templates.with_raw_response.create() @@ -47,7 +47,7 @@ def test_raw_response_create(self, client: PostGrid) -> None: template = response.parse() assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_create(self, client: PostGrid) -> None: with client.print_mail.templates.with_streaming_response.create() as response: @@ -59,7 +59,7 @@ def test_streaming_response_create(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve(self, client: PostGrid) -> None: template = client.print_mail.templates.retrieve( @@ -67,7 +67,7 @@ def test_method_retrieve(self, client: PostGrid) -> None: ) assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_retrieve(self, client: PostGrid) -> None: response = client.print_mail.templates.with_raw_response.retrieve( @@ -79,7 +79,7 @@ def test_raw_response_retrieve(self, client: PostGrid) -> None: template = response.parse() assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_retrieve(self, client: PostGrid) -> None: with client.print_mail.templates.with_streaming_response.retrieve( @@ -93,7 +93,7 @@ def test_streaming_response_retrieve(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_retrieve(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -101,7 +101,7 @@ def test_path_params_retrieve(self, client: PostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update(self, client: PostGrid) -> None: template = client.print_mail.templates.update( @@ -109,7 +109,7 @@ def test_method_update(self, client: PostGrid) -> None: ) assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_with_all_params(self, client: PostGrid) -> None: template = client.print_mail.templates.update( @@ -120,7 +120,7 @@ def test_method_update_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_update(self, client: PostGrid) -> None: response = client.print_mail.templates.with_raw_response.update( @@ -132,7 +132,7 @@ def test_raw_response_update(self, client: PostGrid) -> None: template = response.parse() assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_update(self, client: PostGrid) -> None: with client.print_mail.templates.with_streaming_response.update( @@ -146,7 +146,7 @@ def test_streaming_response_update(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_update(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -154,13 +154,13 @@ def test_path_params_update(self, client: PostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list(self, client: PostGrid) -> None: template = client.print_mail.templates.list() assert_matches_type(SyncSkipLimit[Template], template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_with_all_params(self, client: PostGrid) -> None: template = client.print_mail.templates.list( @@ -170,7 +170,7 @@ def test_method_list_with_all_params(self, client: PostGrid) -> None: ) assert_matches_type(SyncSkipLimit[Template], template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_list(self, client: PostGrid) -> None: response = client.print_mail.templates.with_raw_response.list() @@ -180,7 +180,7 @@ def test_raw_response_list(self, client: PostGrid) -> None: template = response.parse() assert_matches_type(SyncSkipLimit[Template], template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_list(self, client: PostGrid) -> None: with client.print_mail.templates.with_streaming_response.list() as response: @@ -192,7 +192,7 @@ def test_streaming_response_list(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: PostGrid) -> None: template = client.print_mail.templates.delete( @@ -200,7 +200,7 @@ def test_method_delete(self, client: PostGrid) -> None: ) assert_matches_type(TemplateDeleteResponse, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_delete(self, client: PostGrid) -> None: response = client.print_mail.templates.with_raw_response.delete( @@ -212,7 +212,7 @@ def test_raw_response_delete(self, client: PostGrid) -> None: template = response.parse() assert_matches_type(TemplateDeleteResponse, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_delete(self, client: PostGrid) -> None: with client.print_mail.templates.with_streaming_response.delete( @@ -226,7 +226,7 @@ def test_streaming_response_delete(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_path_params_delete(self, client: PostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -240,13 +240,13 @@ class TestAsyncTemplates: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create(self, async_client: AsyncPostGrid) -> None: template = await async_client.print_mail.templates.create() assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) -> None: template = await async_client.print_mail.templates.create( @@ -256,7 +256,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.templates.with_raw_response.create() @@ -266,7 +266,7 @@ async def test_raw_response_create(self, async_client: AsyncPostGrid) -> None: template = await response.parse() assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.templates.with_streaming_response.create() as response: @@ -278,7 +278,7 @@ async def test_streaming_response_create(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: template = await async_client.print_mail.templates.retrieve( @@ -286,7 +286,7 @@ async def test_method_retrieve(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.templates.with_raw_response.retrieve( @@ -298,7 +298,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncPostGrid) -> None: template = await response.parse() assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.templates.with_streaming_response.retrieve( @@ -312,7 +312,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncPostGrid) -> assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -320,7 +320,7 @@ async def test_path_params_retrieve(self, async_client: AsyncPostGrid) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update(self, async_client: AsyncPostGrid) -> None: template = await async_client.print_mail.templates.update( @@ -328,7 +328,7 @@ async def test_method_update(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) -> None: template = await async_client.print_mail.templates.update( @@ -339,7 +339,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncPostGrid) ) assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.templates.with_raw_response.update( @@ -351,7 +351,7 @@ async def test_raw_response_update(self, async_client: AsyncPostGrid) -> None: template = await response.parse() assert_matches_type(Template, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.templates.with_streaming_response.update( @@ -365,7 +365,7 @@ async def test_streaming_response_update(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -373,13 +373,13 @@ async def test_path_params_update(self, async_client: AsyncPostGrid) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list(self, async_client: AsyncPostGrid) -> None: template = await async_client.print_mail.templates.list() assert_matches_type(AsyncSkipLimit[Template], template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> None: template = await async_client.print_mail.templates.list( @@ -389,7 +389,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncPostGrid) -> ) assert_matches_type(AsyncSkipLimit[Template], template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.templates.with_raw_response.list() @@ -399,7 +399,7 @@ async def test_raw_response_list(self, async_client: AsyncPostGrid) -> None: template = await response.parse() assert_matches_type(AsyncSkipLimit[Template], template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.templates.with_streaming_response.list() as response: @@ -411,7 +411,7 @@ async def test_streaming_response_list(self, async_client: AsyncPostGrid) -> Non assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete(self, async_client: AsyncPostGrid) -> None: template = await async_client.print_mail.templates.delete( @@ -419,7 +419,7 @@ async def test_method_delete(self, async_client: AsyncPostGrid) -> None: ) assert_matches_type(TemplateDeleteResponse, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: response = await async_client.print_mail.templates.with_raw_response.delete( @@ -431,7 +431,7 @@ async def test_raw_response_delete(self, async_client: AsyncPostGrid) -> None: template = await response.parse() assert_matches_type(TemplateDeleteResponse, template, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> None: async with async_client.print_mail.templates.with_streaming_response.delete( @@ -445,7 +445,7 @@ async def test_streaming_response_delete(self, async_client: AsyncPostGrid) -> N assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_path_params_delete(self, async_client: AsyncPostGrid) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/test_address_verification.py b/tests/api_resources/test_address_verification.py index a753480..184a596 100644 --- a/tests/api_resources/test_address_verification.py +++ b/tests/api_resources/test_address_verification.py @@ -17,7 +17,7 @@ class TestAddressVerification: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_verify_overload_1(self, client: PostGrid) -> None: address_verification = client.address_verification.verify( @@ -25,7 +25,7 @@ def test_method_verify_overload_1(self, client: PostGrid) -> None: ) assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_verify_with_all_params_overload_1(self, client: PostGrid) -> None: address_verification = client.address_verification.verify( @@ -36,7 +36,7 @@ def test_method_verify_with_all_params_overload_1(self, client: PostGrid) -> Non ) assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_verify_overload_1(self, client: PostGrid) -> None: response = client.address_verification.with_raw_response.verify( @@ -48,7 +48,7 @@ def test_raw_response_verify_overload_1(self, client: PostGrid) -> None: address_verification = response.parse() assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_verify_overload_1(self, client: PostGrid) -> None: with client.address_verification.with_streaming_response.verify( @@ -62,7 +62,7 @@ def test_streaming_response_verify_overload_1(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_verify_overload_2(self, client: PostGrid) -> None: address_verification = client.address_verification.verify( @@ -76,7 +76,7 @@ def test_method_verify_overload_2(self, client: PostGrid) -> None: ) assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_verify_with_all_params_overload_2(self, client: PostGrid) -> None: address_verification = client.address_verification.verify( @@ -95,7 +95,7 @@ def test_method_verify_with_all_params_overload_2(self, client: PostGrid) -> Non ) assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_verify_overload_2(self, client: PostGrid) -> None: response = client.address_verification.with_raw_response.verify( @@ -113,7 +113,7 @@ def test_raw_response_verify_overload_2(self, client: PostGrid) -> None: address_verification = response.parse() assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_verify_overload_2(self, client: PostGrid) -> None: with client.address_verification.with_streaming_response.verify( @@ -139,7 +139,7 @@ class TestAsyncAddressVerification: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_verify_overload_1(self, async_client: AsyncPostGrid) -> None: address_verification = await async_client.address_verification.verify( @@ -147,7 +147,7 @@ async def test_method_verify_overload_1(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_verify_with_all_params_overload_1(self, async_client: AsyncPostGrid) -> None: address_verification = await async_client.address_verification.verify( @@ -158,7 +158,7 @@ async def test_method_verify_with_all_params_overload_1(self, async_client: Asyn ) assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_verify_overload_1(self, async_client: AsyncPostGrid) -> None: response = await async_client.address_verification.with_raw_response.verify( @@ -170,7 +170,7 @@ async def test_raw_response_verify_overload_1(self, async_client: AsyncPostGrid) address_verification = await response.parse() assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_verify_overload_1(self, async_client: AsyncPostGrid) -> None: async with async_client.address_verification.with_streaming_response.verify( @@ -184,7 +184,7 @@ async def test_streaming_response_verify_overload_1(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_verify_overload_2(self, async_client: AsyncPostGrid) -> None: address_verification = await async_client.address_verification.verify( @@ -198,7 +198,7 @@ async def test_method_verify_overload_2(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_verify_with_all_params_overload_2(self, async_client: AsyncPostGrid) -> None: address_verification = await async_client.address_verification.verify( @@ -217,7 +217,7 @@ async def test_method_verify_with_all_params_overload_2(self, async_client: Asyn ) assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_verify_overload_2(self, async_client: AsyncPostGrid) -> None: response = await async_client.address_verification.with_raw_response.verify( @@ -235,7 +235,7 @@ async def test_raw_response_verify_overload_2(self, async_client: AsyncPostGrid) address_verification = await response.parse() assert_matches_type(AddressVerificationVerifyResponse, address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_verify_overload_2(self, async_client: AsyncPostGrid) -> None: async with async_client.address_verification.with_streaming_response.verify( diff --git a/tests/api_resources/test_intl_address_verification.py b/tests/api_resources/test_intl_address_verification.py index 704b4ec..72226a4 100644 --- a/tests/api_resources/test_intl_address_verification.py +++ b/tests/api_resources/test_intl_address_verification.py @@ -17,7 +17,7 @@ class TestIntlAddressVerification: parametrize = pytest.mark.parametrize("client", [False, True], indirect=True, ids=["loose", "strict"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_verify_overload_1(self, client: PostGrid) -> None: intl_address_verification = client.intl_address_verification.verify( @@ -30,7 +30,7 @@ def test_method_verify_overload_1(self, client: PostGrid) -> None: ) assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_verify_with_all_params_overload_1(self, client: PostGrid) -> None: intl_address_verification = client.intl_address_verification.verify( @@ -50,7 +50,7 @@ def test_method_verify_with_all_params_overload_1(self, client: PostGrid) -> Non ) assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_verify_overload_1(self, client: PostGrid) -> None: response = client.intl_address_verification.with_raw_response.verify( @@ -67,7 +67,7 @@ def test_raw_response_verify_overload_1(self, client: PostGrid) -> None: intl_address_verification = response.parse() assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_verify_overload_1(self, client: PostGrid) -> None: with client.intl_address_verification.with_streaming_response.verify( @@ -86,7 +86,7 @@ def test_streaming_response_verify_overload_1(self, client: PostGrid) -> None: assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_verify_overload_2(self, client: PostGrid) -> None: intl_address_verification = client.intl_address_verification.verify( @@ -94,7 +94,7 @@ def test_method_verify_overload_2(self, client: PostGrid) -> None: ) assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_verify_with_all_params_overload_2(self, client: PostGrid) -> None: intl_address_verification = client.intl_address_verification.verify( @@ -105,7 +105,7 @@ def test_method_verify_with_all_params_overload_2(self, client: PostGrid) -> Non ) assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_verify_overload_2(self, client: PostGrid) -> None: response = client.intl_address_verification.with_raw_response.verify( @@ -117,7 +117,7 @@ def test_raw_response_verify_overload_2(self, client: PostGrid) -> None: intl_address_verification = response.parse() assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_verify_overload_2(self, client: PostGrid) -> None: with client.intl_address_verification.with_streaming_response.verify( @@ -137,7 +137,7 @@ class TestAsyncIntlAddressVerification: "async_client", [False, True, {"http_client": "aiohttp"}], indirect=True, ids=["loose", "strict", "aiohttp"] ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_verify_overload_1(self, async_client: AsyncPostGrid) -> None: intl_address_verification = await async_client.intl_address_verification.verify( @@ -150,7 +150,7 @@ async def test_method_verify_overload_1(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_verify_with_all_params_overload_1(self, async_client: AsyncPostGrid) -> None: intl_address_verification = await async_client.intl_address_verification.verify( @@ -170,7 +170,7 @@ async def test_method_verify_with_all_params_overload_1(self, async_client: Asyn ) assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_verify_overload_1(self, async_client: AsyncPostGrid) -> None: response = await async_client.intl_address_verification.with_raw_response.verify( @@ -187,7 +187,7 @@ async def test_raw_response_verify_overload_1(self, async_client: AsyncPostGrid) intl_address_verification = await response.parse() assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_verify_overload_1(self, async_client: AsyncPostGrid) -> None: async with async_client.intl_address_verification.with_streaming_response.verify( @@ -206,7 +206,7 @@ async def test_streaming_response_verify_overload_1(self, async_client: AsyncPos assert cast(Any, response.is_closed) is True - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_verify_overload_2(self, async_client: AsyncPostGrid) -> None: intl_address_verification = await async_client.intl_address_verification.verify( @@ -214,7 +214,7 @@ async def test_method_verify_overload_2(self, async_client: AsyncPostGrid) -> No ) assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_verify_with_all_params_overload_2(self, async_client: AsyncPostGrid) -> None: intl_address_verification = await async_client.intl_address_verification.verify( @@ -225,7 +225,7 @@ async def test_method_verify_with_all_params_overload_2(self, async_client: Asyn ) assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_verify_overload_2(self, async_client: AsyncPostGrid) -> None: response = await async_client.intl_address_verification.with_raw_response.verify( @@ -237,7 +237,7 @@ async def test_raw_response_verify_overload_2(self, async_client: AsyncPostGrid) intl_address_verification = await response.parse() assert_matches_type(IntlAddressVerificationVerifyResponse, intl_address_verification, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_verify_overload_2(self, async_client: AsyncPostGrid) -> None: async with async_client.intl_address_verification.with_streaming_response.verify( From bafddda64c9f7306a22dff79a946ec6986f36cc7 Mon Sep 17 00:00:00 2001 From: "stainless-app[bot]" <142633134+stainless-app[bot]@users.noreply.github.com> Date: Thu, 19 Feb 2026 16:32:27 +0000 Subject: [PATCH 16/16] release: 2.1.0 --- .release-please-manifest.json | 2 +- CHANGELOG.md | 30 ++++++++++++++++++++++++++++++ pyproject.toml | 2 +- src/postgrid/_version.py | 2 +- 4 files changed, 33 insertions(+), 3 deletions(-) diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 337d15d..656a2ef 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "2.0.3" + ".": "2.1.0" } \ No newline at end of file diff --git a/CHANGELOG.md b/CHANGELOG.md index 65302ee..2a9d6f5 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,35 @@ # Changelog +## 2.1.0 (2026-02-19) + +Full Changelog: [v2.0.3...v2.1.0](https://github.com/postgrid/postgrid-python/compare/v2.0.3...v2.1.0) + +### Features + +* **client:** add custom JSON encoder for extended type support ([7daf14d](https://github.com/postgrid/postgrid-python/commit/7daf14d1ea87c9036961bbcc15399e90ed118cbb)) +* **client:** add support for binary request streaming ([9c92b6a](https://github.com/postgrid/postgrid-python/commit/9c92b6a0f2411b015adf447dffa582836bc1ac4a)) + + +### Bug Fixes + +* **client:** loosen auth header validation ([af955ca](https://github.com/postgrid/postgrid-python/commit/af955ca7182b4f032d6d9c10faf060668fa43248)) +* use async_to_httpx_files in patch method ([a3b137a](https://github.com/postgrid/postgrid-python/commit/a3b137ae1ab33697009d7b508a8d22f7349b9dec)) + + +### Chores + +* **ci:** upgrade `actions/github-script` ([e2ea5fd](https://github.com/postgrid/postgrid-python/commit/e2ea5fdecfc467358d53198d37f153ea7f7bf0cf)) +* format all `api.md` files ([0a364e2](https://github.com/postgrid/postgrid-python/commit/0a364e28d4d8c4039925ead02608bcc66f6253f8)) +* **internal:** add `--fix` argument to lint script ([e8d9998](https://github.com/postgrid/postgrid-python/commit/e8d9998a7bc735ebb82e4071f479b6d811746abd)) +* **internal:** add missing files argument to base client ([6dbed91](https://github.com/postgrid/postgrid-python/commit/6dbed918a54c190cda4e2b7c1c8b56867bde3562)) +* **internal:** bump dependencies ([53cb8a0](https://github.com/postgrid/postgrid-python/commit/53cb8a03ab0c3d88881b7c2acdde5288f8511f7e)) +* **internal:** codegen related update ([eb02a83](https://github.com/postgrid/postgrid-python/commit/eb02a837ede94d5440593cb9c921c6e47ae5a0ab)) +* **internal:** fix lint error on Python 3.14 ([8a7fe14](https://github.com/postgrid/postgrid-python/commit/8a7fe146bf634f2fab49203e50eca29f43f3f1c3)) +* **internal:** remove mock server code ([961b979](https://github.com/postgrid/postgrid-python/commit/961b979236edcd88d3c3f2b03f1033940b188bd2)) +* **internal:** update `actions/checkout` version ([0d17288](https://github.com/postgrid/postgrid-python/commit/0d1728886ee999032574dd9877bc85c84930bc3b)) +* speedup initial import ([32fb2cc](https://github.com/postgrid/postgrid-python/commit/32fb2cceb7859e77a4840e4f45bc782123aa0359)) +* update mock server docs ([168a3b8](https://github.com/postgrid/postgrid-python/commit/168a3b8c77755038a1fefd557d71ad49f753a360)) + ## 2.0.3 (2025-12-09) Full Changelog: [v2.0.2...v2.0.3](https://github.com/postgrid/postgrid-python/compare/v2.0.2...v2.0.3) diff --git a/pyproject.toml b/pyproject.toml index 542f91b..fa9eb2c 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "postgrid-python" -version = "2.0.3" +version = "2.1.0" description = "The official Python library for the PostGrid API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/src/postgrid/_version.py b/src/postgrid/_version.py index 0544c30..1b45248 100644 --- a/src/postgrid/_version.py +++ b/src/postgrid/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "postgrid" -__version__ = "2.0.3" # x-release-please-version +__version__ = "2.1.0" # x-release-please-version