diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index e6aa1481..d70eb8da 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -24,7 +24,7 @@ jobs: - name: Install uv uses: astral-sh/setup-uv@v5 with: - version: '0.9.13' + version: '0.10.2' - name: Install dependencies run: uv sync --all-extras @@ -46,7 +46,7 @@ jobs: - name: Install uv uses: astral-sh/setup-uv@v5 with: - version: '0.9.13' + version: '0.10.2' - name: Install dependencies run: uv sync --all-extras @@ -55,14 +55,18 @@ jobs: run: uv build - name: Get GitHub OIDC Token - if: github.repository == 'stainless-sdks/sent-dm-python' + if: |- + github.repository == 'stainless-sdks/sent-dm-python' && + !startsWith(github.ref, 'refs/heads/stl/') id: github-oidc uses: actions/github-script@v8 with: script: core.setOutput('github_token', await core.getIDToken()); - name: Upload tarball - if: github.repository == 'stainless-sdks/sent-dm-python' + if: |- + github.repository == 'stainless-sdks/sent-dm-python' && + !startsWith(github.ref, 'refs/heads/stl/') env: URL: https://pkg.stainless.com/s AUTH: ${{ steps.github-oidc.outputs.github_token }} @@ -80,7 +84,7 @@ jobs: - name: Install uv uses: astral-sh/setup-uv@v5 with: - version: '0.9.13' + version: '0.10.2' - name: Bootstrap run: ./scripts/bootstrap diff --git a/.release-please-manifest.json b/.release-please-manifest.json index 6538ca91..2b28d6ec 100644 --- a/.release-please-manifest.json +++ b/.release-please-manifest.json @@ -1,3 +1,3 @@ { - ".": "0.8.0" + ".": "0.8.1" } \ No newline at end of file diff --git a/.stats.yml b/.stats.yml index 85a351b6..f982b6ed 100644 --- a/.stats.yml +++ b/.stats.yml @@ -1,4 +1,4 @@ configured_endpoints: 44 -openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sent%2Fsent-dm-433bfd8c688a6b6d2d4f964bb59121d692798f4e2bb6cb47f6110c4f0e1f638d.yml -openapi_spec_hash: 5378295d401c8c1152c1946cc7dbd69f -config_hash: 43a0daa5b05d44a1620e3da0ea6f4fdc +openapi_spec_url: https://storage.googleapis.com/stainless-sdk-openapi-specs/sent%2Fsent-dm-c1e54655c045f25bd08ecc70c87f938e429911c413c09957d83d3eb9eaab2372.yml +openapi_spec_hash: 44b7f99e2660bde83eff178b9d4ec00c +config_hash: d475a61f5b59375bf562f85f19b80409 diff --git a/CHANGELOG.md b/CHANGELOG.md index 2b10eda3..c4d1312d 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -1,5 +1,17 @@ # Changelog +## 0.8.1 (2026-03-11) + +Full Changelog: [v0.8.0...v0.8.1](https://github.com/sentdm/sent-dm-python/compare/v0.8.0...v0.8.1) + +### Chores + +* **ci:** bump uv version ([d78a321](https://github.com/sentdm/sent-dm-python/commit/d78a321a68d21ef2c3d2b026a300f08676cb763c)) +* **ci:** skip uploading artifacts on stainless-internal branches ([bea8db4](https://github.com/sentdm/sent-dm-python/commit/bea8db458b817c77e4a0fbb3c2dbe2ec0a49a1e0)) +* **internal:** codegen related update ([2d412a1](https://github.com/sentdm/sent-dm-python/commit/2d412a10404c8b67d8b078122d1bce7fc7428a01)) +* **internal:** make `test_proxy_environment_variables` more resilient to env ([99f2ac4](https://github.com/sentdm/sent-dm-python/commit/99f2ac4367e0e62c9ad06e95c535080e928fd5a7)) +* **internal:** refactor authentication internals ([5b5b2e3](https://github.com/sentdm/sent-dm-python/commit/5b5b2e32d87fc7447fd435f9db4f41ce8bccab24)) + ## 0.8.0 (2026-02-18) Full Changelog: [v0.7.0...v0.8.0](https://github.com/sentdm/sent-dm-python/compare/v0.7.0...v0.8.0) diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md index b08632a8..b66af0d6 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/README.md b/README.md index 85abb8f2..b6919f58 100644 --- a/README.md +++ b/README.md @@ -9,6 +9,15 @@ and offers both synchronous and asynchronous clients powered by [httpx](https:// It is generated with [Stainless](https://www.stainless.com/). +## MCP Server + +Use the Sent Dm MCP Server to enable AI assistants to interact with this API, allowing them to explore endpoints, make test requests, and use documentation to help integrate this SDK into your application. + +[![Add to Cursor](https://cursor.com/deeplink/mcp-install-dark.svg)](https://cursor.com/en-US/install-mcp?name=%40sentdm%2Fsentdm-mcp&config=eyJjb21tYW5kIjoibnB4IiwiYXJncyI6WyIteSIsIkBzZW50ZG0vc2VudGRtLW1jcCJdLCJlbnYiOnsiU0VOVF9ETV9BUElfS0VZIjoiTXkgQVBJIEtleSJ9fQ) +[![Install in VS Code](https://img.shields.io/badge/_-Add_to_VS_Code-blue?style=for-the-badge&logo=data:image/svg%2bxml;base64,PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIGZpbGw9Im5vbmUiIHZpZXdCb3g9IjAgMCA0MCA0MCI+PHBhdGggZmlsbD0iI0VFRSIgZmlsbC1ydWxlPSJldmVub2RkIiBkPSJNMzAuMjM1IDM5Ljg4NGEyLjQ5MSAyLjQ5MSAwIDAgMS0xLjc4MS0uNzNMMTIuNyAyNC43OGwtMy40NiAyLjYyNC0zLjQwNiAyLjU4MmExLjY2NSAxLjY2NSAwIDAgMS0xLjA4Mi4zMzggMS42NjQgMS42NjQgMCAwIDEtMS4wNDYtLjQzMWwtMi4yLTJhMS42NjYgMS42NjYgMCAwIDEgMC0yLjQ2M0w3LjQ1OCAyMCA0LjY3IDE3LjQ1MyAxLjUwNyAxNC41N2ExLjY2NSAxLjY2NSAwIDAgMSAwLTIuNDYzbDIuMi0yYTEuNjY1IDEuNjY1IDAgMCAxIDIuMTMtLjA5N2w2Ljg2MyA1LjIwOUwyOC40NTIuODQ0YTIuNDg4IDIuNDg4IDAgMCAxIDEuODQxLS43MjljLjM1MS4wMDkuNjk5LjA5MSAxLjAxOS4yNDVsOC4yMzYgMy45NjFhMi41IDIuNSAwIDAgMSAxLjQxNSAyLjI1M3YuMDk5LS4wNDVWMzMuMzd2LS4wNDUuMDk1YTIuNTAxIDIuNTAxIDAgMCAxLTEuNDE2IDIuMjU3bC04LjIzNSAzLjk2MWEyLjQ5MiAyLjQ5MiAwIDAgMS0xLjA3Ny4yNDZabS43MTYtMjguOTQ3LTExLjk0OCA5LjA2MiAxMS45NTIgOS4wNjUtLjAwNC0xOC4xMjdaIi8+PC9zdmc+)](https://vscode.stainless.com/mcp/%7B%22name%22%3A%22%40sentdm%2Fsentdm-mcp%22%2C%22command%22%3A%22npx%22%2C%22args%22%3A%5B%22-y%22%2C%22%40sentdm%2Fsentdm-mcp%22%5D%2C%22env%22%3A%7B%22SENT_DM_API_KEY%22%3A%22My%20API%20Key%22%7D%7D) + +> Note: You may need to set environment variables in your MCP client. + ## Documentation The REST API documentation can be found on [docs.sent.dm](https://docs.sent.dm). The full API of this library can be found in [api.md](api.md). diff --git a/pyproject.toml b/pyproject.toml index 68fdb16e..a98c4f9f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -1,6 +1,6 @@ [project] name = "sentdm" -version = "0.8.0" +version = "0.8.1" description = "The official Python library for the sent-dm API" dynamic = ["readme"] license = "Apache-2.0" diff --git a/scripts/mock b/scripts/mock deleted file mode 100755 index 0b28f6ea..00000000 --- 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 b56970b7..fe50ebb1 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 diff --git a/src/sent_dm/_base_client.py b/src/sent_dm/_base_client.py index b5996672..09214d70 100644 --- a/src/sent_dm/_base_client.py +++ b/src/sent_dm/_base_client.py @@ -63,7 +63,7 @@ ) from ._utils import is_dict, is_list, asyncify, is_given, lru_cache, is_mapping from ._compat import PYDANTIC_V1, model_copy, model_dump -from ._models import GenericModel, FinalRequestOptions, validate_type, construct_type +from ._models import GenericModel, SecurityOptions, FinalRequestOptions, validate_type, construct_type from ._response import ( APIResponse, BaseAPIResponse, @@ -432,9 +432,27 @@ def _make_status_error( ) -> _exceptions.APIStatusError: raise NotImplementedError() + def _auth_headers( + self, + security: SecurityOptions, # noqa: ARG002 + ) -> dict[str, str]: + return {} + + def _auth_query( + self, + security: SecurityOptions, # noqa: ARG002 + ) -> dict[str, str]: + return {} + + def _custom_auth( + self, + security: SecurityOptions, # noqa: ARG002 + ) -> httpx.Auth | None: + return None + def _build_headers(self, options: FinalRequestOptions, *, retries_taken: int = 0) -> httpx.Headers: custom_headers = options.headers or {} - headers_dict = _merge_mappings(self.default_headers, custom_headers) + headers_dict = _merge_mappings({**self._auth_headers(options.security), **self.default_headers}, custom_headers) self._validate_headers(headers_dict, custom_headers) # headers are case-insensitive while dictionaries are not. @@ -506,7 +524,7 @@ def _build_request( raise RuntimeError(f"Unexpected JSON data type, {type(json_data)}, cannot merge with `extra_body`") headers = self._build_headers(options, retries_taken=retries_taken) - params = _merge_mappings(self.default_query, options.params) + params = _merge_mappings({**self._auth_query(options.security), **self.default_query}, options.params) content_type = headers.get("Content-Type") files = options.files @@ -671,7 +689,6 @@ def default_headers(self) -> dict[str, str | Omit]: "Content-Type": "application/json", "User-Agent": self.user_agent, **self.platform_headers(), - **self.auth_headers, **self._custom_headers, } @@ -990,8 +1007,9 @@ def request( self._prepare_request(request) kwargs: HttpxSendArgs = {} - if self.custom_auth is not None: - kwargs["auth"] = self.custom_auth + custom_auth = self._custom_auth(options.security) + if custom_auth is not None: + kwargs["auth"] = custom_auth if options.follow_redirects is not None: kwargs["follow_redirects"] = options.follow_redirects @@ -1952,6 +1970,7 @@ def make_request_options( idempotency_key: str | None = None, timeout: float | httpx.Timeout | None | NotGiven = not_given, post_parser: PostParser | NotGiven = not_given, + security: SecurityOptions | None = None, ) -> RequestOptions: """Create a dict of type RequestOptions without keys of NotGiven values.""" options: RequestOptions = {} @@ -1977,6 +1996,9 @@ def make_request_options( # internal options["post_parser"] = post_parser # type: ignore + if security is not None: + options["security"] = security + return options diff --git a/src/sent_dm/_client.py b/src/sent_dm/_client.py index e49d4a2e..0a0aa78c 100644 --- a/src/sent_dm/_client.py +++ b/src/sent_dm/_client.py @@ -21,6 +21,7 @@ ) from ._utils import is_given, get_async_library from ._compat import cached_property +from ._models import SecurityOptions from ._version import __version__ from ._streaming import Stream as Stream, AsyncStream as AsyncStream from ._exceptions import SentDmError, APIStatusError @@ -102,30 +103,35 @@ def __init__( @cached_property def webhooks(self) -> WebhooksResource: + """Configure webhook endpoints for real-time event delivery""" from .resources.webhooks import WebhooksResource return WebhooksResource(self) @cached_property def users(self) -> UsersResource: + """Invite, update, and manage organization users and roles""" from .resources.users import UsersResource return UsersResource(self) @cached_property def templates(self) -> TemplatesResource: + """Manage message templates with variable substitution""" from .resources.templates import TemplatesResource return TemplatesResource(self) @cached_property def profiles(self) -> ProfilesResource: + """Manage organization profiles""" from .resources.profiles import ProfilesResource return ProfilesResource(self) @cached_property def messages(self) -> MessagesResource: + """Send and track SMS and WhatsApp messages""" from .resources.messages import MessagesResource return MessagesResource(self) @@ -138,18 +144,21 @@ def lookup(self) -> LookupResource: @cached_property def contacts(self) -> ContactsResource: + """Create, update, and manage customer contact lists""" from .resources.contacts import ContactsResource return ContactsResource(self) @cached_property def brands(self) -> BrandsResource: + """Register and manage 10DLC brands for SMS compliance""" from .resources.brands import BrandsResource return BrandsResource(self) @cached_property def me(self) -> MeResource: + """Retrieve account details""" from .resources.me import MeResource return MeResource(self) @@ -167,9 +176,14 @@ def with_streaming_response(self) -> SentDmWithStreamedResponse: def qs(self) -> Querystring: return Querystring(array_format="comma") - @property @override - def auth_headers(self) -> dict[str, str]: + def _auth_headers(self, security: SecurityOptions) -> dict[str, str]: + return { + **(self._customer_api_key if security.get("customer_api_key", False) else {}), + } + + @property + def _customer_api_key(self) -> dict[str, str]: api_key = self.api_key return {"x-api-key": api_key} @@ -324,30 +338,35 @@ def __init__( @cached_property def webhooks(self) -> AsyncWebhooksResource: + """Configure webhook endpoints for real-time event delivery""" from .resources.webhooks import AsyncWebhooksResource return AsyncWebhooksResource(self) @cached_property def users(self) -> AsyncUsersResource: + """Invite, update, and manage organization users and roles""" from .resources.users import AsyncUsersResource return AsyncUsersResource(self) @cached_property def templates(self) -> AsyncTemplatesResource: + """Manage message templates with variable substitution""" from .resources.templates import AsyncTemplatesResource return AsyncTemplatesResource(self) @cached_property def profiles(self) -> AsyncProfilesResource: + """Manage organization profiles""" from .resources.profiles import AsyncProfilesResource return AsyncProfilesResource(self) @cached_property def messages(self) -> AsyncMessagesResource: + """Send and track SMS and WhatsApp messages""" from .resources.messages import AsyncMessagesResource return AsyncMessagesResource(self) @@ -360,18 +379,21 @@ def lookup(self) -> AsyncLookupResource: @cached_property def contacts(self) -> AsyncContactsResource: + """Create, update, and manage customer contact lists""" from .resources.contacts import AsyncContactsResource return AsyncContactsResource(self) @cached_property def brands(self) -> AsyncBrandsResource: + """Register and manage 10DLC brands for SMS compliance""" from .resources.brands import AsyncBrandsResource return AsyncBrandsResource(self) @cached_property def me(self) -> AsyncMeResource: + """Retrieve account details""" from .resources.me import AsyncMeResource return AsyncMeResource(self) @@ -389,9 +411,14 @@ def with_streaming_response(self) -> AsyncSentDmWithStreamedResponse: def qs(self) -> Querystring: return Querystring(array_format="comma") - @property @override - def auth_headers(self) -> dict[str, str]: + def _auth_headers(self, security: SecurityOptions) -> dict[str, str]: + return { + **(self._customer_api_key if security.get("customer_api_key", False) else {}), + } + + @property + def _customer_api_key(self) -> dict[str, str]: api_key = self.api_key return {"x-api-key": api_key} @@ -497,30 +524,35 @@ def __init__(self, client: SentDm) -> None: @cached_property def webhooks(self) -> webhooks.WebhooksResourceWithRawResponse: + """Configure webhook endpoints for real-time event delivery""" from .resources.webhooks import WebhooksResourceWithRawResponse return WebhooksResourceWithRawResponse(self._client.webhooks) @cached_property def users(self) -> users.UsersResourceWithRawResponse: + """Invite, update, and manage organization users and roles""" from .resources.users import UsersResourceWithRawResponse return UsersResourceWithRawResponse(self._client.users) @cached_property def templates(self) -> templates.TemplatesResourceWithRawResponse: + """Manage message templates with variable substitution""" from .resources.templates import TemplatesResourceWithRawResponse return TemplatesResourceWithRawResponse(self._client.templates) @cached_property def profiles(self) -> profiles.ProfilesResourceWithRawResponse: + """Manage organization profiles""" from .resources.profiles import ProfilesResourceWithRawResponse return ProfilesResourceWithRawResponse(self._client.profiles) @cached_property def messages(self) -> messages.MessagesResourceWithRawResponse: + """Send and track SMS and WhatsApp messages""" from .resources.messages import MessagesResourceWithRawResponse return MessagesResourceWithRawResponse(self._client.messages) @@ -533,18 +565,21 @@ def lookup(self) -> lookup.LookupResourceWithRawResponse: @cached_property def contacts(self) -> contacts.ContactsResourceWithRawResponse: + """Create, update, and manage customer contact lists""" from .resources.contacts import ContactsResourceWithRawResponse return ContactsResourceWithRawResponse(self._client.contacts) @cached_property def brands(self) -> brands.BrandsResourceWithRawResponse: + """Register and manage 10DLC brands for SMS compliance""" from .resources.brands import BrandsResourceWithRawResponse return BrandsResourceWithRawResponse(self._client.brands) @cached_property def me(self) -> me.MeResourceWithRawResponse: + """Retrieve account details""" from .resources.me import MeResourceWithRawResponse return MeResourceWithRawResponse(self._client.me) @@ -558,30 +593,35 @@ def __init__(self, client: AsyncSentDm) -> None: @cached_property def webhooks(self) -> webhooks.AsyncWebhooksResourceWithRawResponse: + """Configure webhook endpoints for real-time event delivery""" from .resources.webhooks import AsyncWebhooksResourceWithRawResponse return AsyncWebhooksResourceWithRawResponse(self._client.webhooks) @cached_property def users(self) -> users.AsyncUsersResourceWithRawResponse: + """Invite, update, and manage organization users and roles""" from .resources.users import AsyncUsersResourceWithRawResponse return AsyncUsersResourceWithRawResponse(self._client.users) @cached_property def templates(self) -> templates.AsyncTemplatesResourceWithRawResponse: + """Manage message templates with variable substitution""" from .resources.templates import AsyncTemplatesResourceWithRawResponse return AsyncTemplatesResourceWithRawResponse(self._client.templates) @cached_property def profiles(self) -> profiles.AsyncProfilesResourceWithRawResponse: + """Manage organization profiles""" from .resources.profiles import AsyncProfilesResourceWithRawResponse return AsyncProfilesResourceWithRawResponse(self._client.profiles) @cached_property def messages(self) -> messages.AsyncMessagesResourceWithRawResponse: + """Send and track SMS and WhatsApp messages""" from .resources.messages import AsyncMessagesResourceWithRawResponse return AsyncMessagesResourceWithRawResponse(self._client.messages) @@ -594,18 +634,21 @@ def lookup(self) -> lookup.AsyncLookupResourceWithRawResponse: @cached_property def contacts(self) -> contacts.AsyncContactsResourceWithRawResponse: + """Create, update, and manage customer contact lists""" from .resources.contacts import AsyncContactsResourceWithRawResponse return AsyncContactsResourceWithRawResponse(self._client.contacts) @cached_property def brands(self) -> brands.AsyncBrandsResourceWithRawResponse: + """Register and manage 10DLC brands for SMS compliance""" from .resources.brands import AsyncBrandsResourceWithRawResponse return AsyncBrandsResourceWithRawResponse(self._client.brands) @cached_property def me(self) -> me.AsyncMeResourceWithRawResponse: + """Retrieve account details""" from .resources.me import AsyncMeResourceWithRawResponse return AsyncMeResourceWithRawResponse(self._client.me) @@ -619,30 +662,35 @@ def __init__(self, client: SentDm) -> None: @cached_property def webhooks(self) -> webhooks.WebhooksResourceWithStreamingResponse: + """Configure webhook endpoints for real-time event delivery""" from .resources.webhooks import WebhooksResourceWithStreamingResponse return WebhooksResourceWithStreamingResponse(self._client.webhooks) @cached_property def users(self) -> users.UsersResourceWithStreamingResponse: + """Invite, update, and manage organization users and roles""" from .resources.users import UsersResourceWithStreamingResponse return UsersResourceWithStreamingResponse(self._client.users) @cached_property def templates(self) -> templates.TemplatesResourceWithStreamingResponse: + """Manage message templates with variable substitution""" from .resources.templates import TemplatesResourceWithStreamingResponse return TemplatesResourceWithStreamingResponse(self._client.templates) @cached_property def profiles(self) -> profiles.ProfilesResourceWithStreamingResponse: + """Manage organization profiles""" from .resources.profiles import ProfilesResourceWithStreamingResponse return ProfilesResourceWithStreamingResponse(self._client.profiles) @cached_property def messages(self) -> messages.MessagesResourceWithStreamingResponse: + """Send and track SMS and WhatsApp messages""" from .resources.messages import MessagesResourceWithStreamingResponse return MessagesResourceWithStreamingResponse(self._client.messages) @@ -655,18 +703,21 @@ def lookup(self) -> lookup.LookupResourceWithStreamingResponse: @cached_property def contacts(self) -> contacts.ContactsResourceWithStreamingResponse: + """Create, update, and manage customer contact lists""" from .resources.contacts import ContactsResourceWithStreamingResponse return ContactsResourceWithStreamingResponse(self._client.contacts) @cached_property def brands(self) -> brands.BrandsResourceWithStreamingResponse: + """Register and manage 10DLC brands for SMS compliance""" from .resources.brands import BrandsResourceWithStreamingResponse return BrandsResourceWithStreamingResponse(self._client.brands) @cached_property def me(self) -> me.MeResourceWithStreamingResponse: + """Retrieve account details""" from .resources.me import MeResourceWithStreamingResponse return MeResourceWithStreamingResponse(self._client.me) @@ -680,30 +731,35 @@ def __init__(self, client: AsyncSentDm) -> None: @cached_property def webhooks(self) -> webhooks.AsyncWebhooksResourceWithStreamingResponse: + """Configure webhook endpoints for real-time event delivery""" from .resources.webhooks import AsyncWebhooksResourceWithStreamingResponse return AsyncWebhooksResourceWithStreamingResponse(self._client.webhooks) @cached_property def users(self) -> users.AsyncUsersResourceWithStreamingResponse: + """Invite, update, and manage organization users and roles""" from .resources.users import AsyncUsersResourceWithStreamingResponse return AsyncUsersResourceWithStreamingResponse(self._client.users) @cached_property def templates(self) -> templates.AsyncTemplatesResourceWithStreamingResponse: + """Manage message templates with variable substitution""" from .resources.templates import AsyncTemplatesResourceWithStreamingResponse return AsyncTemplatesResourceWithStreamingResponse(self._client.templates) @cached_property def profiles(self) -> profiles.AsyncProfilesResourceWithStreamingResponse: + """Manage organization profiles""" from .resources.profiles import AsyncProfilesResourceWithStreamingResponse return AsyncProfilesResourceWithStreamingResponse(self._client.profiles) @cached_property def messages(self) -> messages.AsyncMessagesResourceWithStreamingResponse: + """Send and track SMS and WhatsApp messages""" from .resources.messages import AsyncMessagesResourceWithStreamingResponse return AsyncMessagesResourceWithStreamingResponse(self._client.messages) @@ -716,18 +772,21 @@ def lookup(self) -> lookup.AsyncLookupResourceWithStreamingResponse: @cached_property def contacts(self) -> contacts.AsyncContactsResourceWithStreamingResponse: + """Create, update, and manage customer contact lists""" from .resources.contacts import AsyncContactsResourceWithStreamingResponse return AsyncContactsResourceWithStreamingResponse(self._client.contacts) @cached_property def brands(self) -> brands.AsyncBrandsResourceWithStreamingResponse: + """Register and manage 10DLC brands for SMS compliance""" from .resources.brands import AsyncBrandsResourceWithStreamingResponse return AsyncBrandsResourceWithStreamingResponse(self._client.brands) @cached_property def me(self) -> me.AsyncMeResourceWithStreamingResponse: + """Retrieve account details""" from .resources.me import AsyncMeResourceWithStreamingResponse return AsyncMeResourceWithStreamingResponse(self._client.me) diff --git a/src/sent_dm/_models.py b/src/sent_dm/_models.py index 29070e05..a3230855 100644 --- a/src/sent_dm/_models.py +++ b/src/sent_dm/_models.py @@ -791,6 +791,10 @@ def _create_pydantic_model(type_: _T) -> Type[RootModel[_T]]: return RootModel[type_] # type: ignore +class SecurityOptions(TypedDict, total=False): + customer_api_key: bool + + class FinalRequestOptionsInput(TypedDict, total=False): method: Required[str] url: Required[str] @@ -804,6 +808,7 @@ class FinalRequestOptionsInput(TypedDict, total=False): json_data: Body extra_json: AnyMapping follow_redirects: bool + security: SecurityOptions @final @@ -818,6 +823,7 @@ class FinalRequestOptions(pydantic.BaseModel): idempotency_key: Union[str, None] = None post_parser: Union[Callable[[Any], Any], NotGiven] = NotGiven() follow_redirects: Union[bool, None] = None + security: SecurityOptions = {"customer_api_key": True} 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 diff --git a/src/sent_dm/_response.py b/src/sent_dm/_response.py index 541f82cc..258adbc1 100644 --- a/src/sent_dm/_response.py +++ b/src/sent_dm/_response.py @@ -152,6 +152,7 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T: ), response=self.http_response, client=cast(Any, self._client), + options=self._options, ), ) @@ -162,6 +163,7 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T: cast_to=extract_stream_chunk_type(self._stream_cls), response=self.http_response, client=cast(Any, self._client), + options=self._options, ), ) @@ -175,6 +177,7 @@ def _parse(self, *, to: type[_T] | None = None) -> R | _T: cast_to=cast_to, response=self.http_response, client=cast(Any, self._client), + options=self._options, ), ) diff --git a/src/sent_dm/_streaming.py b/src/sent_dm/_streaming.py index 596c21e7..d0aa5727 100644 --- a/src/sent_dm/_streaming.py +++ b/src/sent_dm/_streaming.py @@ -4,7 +4,7 @@ import json import inspect from types import TracebackType -from typing import TYPE_CHECKING, Any, Generic, TypeVar, Iterator, AsyncIterator, cast +from typing import TYPE_CHECKING, Any, Generic, TypeVar, Iterator, Optional, AsyncIterator, cast from typing_extensions import Self, Protocol, TypeGuard, override, get_origin, runtime_checkable import httpx @@ -13,6 +13,7 @@ if TYPE_CHECKING: from ._client import SentDm, AsyncSentDm + from ._models import FinalRequestOptions _T = TypeVar("_T") @@ -22,7 +23,7 @@ class Stream(Generic[_T]): """Provides the core interface to iterate over a synchronous stream response.""" response: httpx.Response - + _options: Optional[FinalRequestOptions] = None _decoder: SSEBytesDecoder def __init__( @@ -31,10 +32,12 @@ def __init__( cast_to: type[_T], response: httpx.Response, client: SentDm, + options: Optional[FinalRequestOptions] = None, ) -> None: self.response = response self._cast_to = cast_to self._client = client + self._options = options self._decoder = client._make_sse_decoder() self._iterator = self.__stream__() @@ -85,7 +88,7 @@ class AsyncStream(Generic[_T]): """Provides the core interface to iterate over an asynchronous stream response.""" response: httpx.Response - + _options: Optional[FinalRequestOptions] = None _decoder: SSEDecoder | SSEBytesDecoder def __init__( @@ -94,10 +97,12 @@ def __init__( cast_to: type[_T], response: httpx.Response, client: AsyncSentDm, + options: Optional[FinalRequestOptions] = None, ) -> None: self.response = response self._cast_to = cast_to self._client = client + self._options = options self._decoder = client._make_sse_decoder() self._iterator = self.__stream__() diff --git a/src/sent_dm/_types.py b/src/sent_dm/_types.py index 1e0e6f6c..8f43c65b 100644 --- a/src/sent_dm/_types.py +++ b/src/sent_dm/_types.py @@ -36,7 +36,7 @@ from httpx import URL, Proxy, Timeout, Response, BaseTransport, AsyncBaseTransport if TYPE_CHECKING: - from ._models import BaseModel + from ._models import BaseModel, SecurityOptions from ._response import APIResponse, AsyncAPIResponse Transport = BaseTransport @@ -121,6 +121,7 @@ class RequestOptions(TypedDict, total=False): extra_json: AnyMapping idempotency_key: str follow_redirects: bool + security: SecurityOptions # Sentinel class used until PEP 0661 is accepted diff --git a/src/sent_dm/_version.py b/src/sent_dm/_version.py index 7bbe01de..370d30e0 100644 --- a/src/sent_dm/_version.py +++ b/src/sent_dm/_version.py @@ -1,4 +1,4 @@ # File generated from our OpenAPI spec by Stainless. See CONTRIBUTING.md for details. __title__ = "sent_dm" -__version__ = "0.8.0" # x-release-please-version +__version__ = "0.8.1" # x-release-please-version diff --git a/src/sent_dm/resources/brands/brands.py b/src/sent_dm/resources/brands/brands.py index 47ab5a84..a8c30126 100644 --- a/src/sent_dm/resources/brands/brands.py +++ b/src/sent_dm/resources/brands/brands.py @@ -32,8 +32,11 @@ class BrandsResource(SyncAPIResource): + """Register and manage 10DLC brands for SMS compliance""" + @cached_property def campaigns(self) -> CampaignsResource: + """Register and manage 10DLC brands for SMS compliance""" return CampaignsResource(self._client) @cached_property @@ -217,8 +220,11 @@ def delete( class AsyncBrandsResource(AsyncAPIResource): + """Register and manage 10DLC brands for SMS compliance""" + @cached_property def campaigns(self) -> AsyncCampaignsResource: + """Register and manage 10DLC brands for SMS compliance""" return AsyncCampaignsResource(self._client) @cached_property @@ -420,6 +426,7 @@ def __init__(self, brands: BrandsResource) -> None: @cached_property def campaigns(self) -> CampaignsResourceWithRawResponse: + """Register and manage 10DLC brands for SMS compliance""" return CampaignsResourceWithRawResponse(self._brands.campaigns) @@ -442,6 +449,7 @@ def __init__(self, brands: AsyncBrandsResource) -> None: @cached_property def campaigns(self) -> AsyncCampaignsResourceWithRawResponse: + """Register and manage 10DLC brands for SMS compliance""" return AsyncCampaignsResourceWithRawResponse(self._brands.campaigns) @@ -464,6 +472,7 @@ def __init__(self, brands: BrandsResource) -> None: @cached_property def campaigns(self) -> CampaignsResourceWithStreamingResponse: + """Register and manage 10DLC brands for SMS compliance""" return CampaignsResourceWithStreamingResponse(self._brands.campaigns) @@ -486,4 +495,5 @@ def __init__(self, brands: AsyncBrandsResource) -> None: @cached_property def campaigns(self) -> AsyncCampaignsResourceWithStreamingResponse: + """Register and manage 10DLC brands for SMS compliance""" return AsyncCampaignsResourceWithStreamingResponse(self._brands.campaigns) diff --git a/src/sent_dm/resources/brands/campaigns.py b/src/sent_dm/resources/brands/campaigns.py index af7e9035..27ab7e65 100644 --- a/src/sent_dm/resources/brands/campaigns.py +++ b/src/sent_dm/resources/brands/campaigns.py @@ -24,6 +24,8 @@ class CampaignsResource(SyncAPIResource): + """Register and manage 10DLC brands for SMS compliance""" + @cached_property def with_raw_response(self) -> CampaignsResourceWithRawResponse: """ @@ -228,6 +230,8 @@ def delete( class AsyncCampaignsResource(AsyncAPIResource): + """Register and manage 10DLC brands for SMS compliance""" + @cached_property def with_raw_response(self) -> AsyncCampaignsResourceWithRawResponse: """ diff --git a/src/sent_dm/resources/contacts.py b/src/sent_dm/resources/contacts.py index 997523e8..d075fa9a 100644 --- a/src/sent_dm/resources/contacts.py +++ b/src/sent_dm/resources/contacts.py @@ -25,6 +25,8 @@ class ContactsResource(SyncAPIResource): + """Create, update, and manage customer contact lists""" + @cached_property def with_raw_response(self) -> ContactsResourceWithRawResponse: """ @@ -282,6 +284,8 @@ def delete( class AsyncContactsResource(AsyncAPIResource): + """Create, update, and manage customer contact lists""" + @cached_property def with_raw_response(self) -> AsyncContactsResourceWithRawResponse: """ diff --git a/src/sent_dm/resources/me.py b/src/sent_dm/resources/me.py index 04ae8879..5bbece97 100644 --- a/src/sent_dm/resources/me.py +++ b/src/sent_dm/resources/me.py @@ -20,6 +20,8 @@ class MeResource(SyncAPIResource): + """Retrieve account details""" + @cached_property def with_raw_response(self) -> MeResourceWithRawResponse: """ @@ -65,6 +67,8 @@ def retrieve( class AsyncMeResource(AsyncAPIResource): + """Retrieve account details""" + @cached_property def with_raw_response(self) -> AsyncMeResourceWithRawResponse: """ diff --git a/src/sent_dm/resources/messages.py b/src/sent_dm/resources/messages.py index 4c980b72..eb883019 100644 --- a/src/sent_dm/resources/messages.py +++ b/src/sent_dm/resources/messages.py @@ -26,6 +26,8 @@ class MessagesResource(SyncAPIResource): + """Send and track SMS and WhatsApp messages""" + @cached_property def with_raw_response(self) -> MessagesResourceWithRawResponse: """ @@ -178,6 +180,8 @@ def send( class AsyncMessagesResource(AsyncAPIResource): + """Send and track SMS and WhatsApp messages""" + @cached_property def with_raw_response(self) -> AsyncMessagesResourceWithRawResponse: """ diff --git a/src/sent_dm/resources/profiles.py b/src/sent_dm/resources/profiles.py index 642e1c15..a81d6d30 100644 --- a/src/sent_dm/resources/profiles.py +++ b/src/sent_dm/resources/profiles.py @@ -25,6 +25,8 @@ class ProfilesResource(SyncAPIResource): + """Manage organization profiles""" + @cached_property def with_raw_response(self) -> ProfilesResourceWithRawResponse: """ @@ -427,6 +429,8 @@ def complete( class AsyncProfilesResource(AsyncAPIResource): + """Manage organization profiles""" + @cached_property def with_raw_response(self) -> AsyncProfilesResourceWithRawResponse: """ diff --git a/src/sent_dm/resources/templates.py b/src/sent_dm/resources/templates.py index 42d2650a..116c3c68 100644 --- a/src/sent_dm/resources/templates.py +++ b/src/sent_dm/resources/templates.py @@ -31,6 +31,8 @@ class TemplatesResource(SyncAPIResource): + """Manage message templates with variable substitution""" + @cached_property def with_raw_response(self) -> TemplatesResourceWithRawResponse: """ @@ -327,6 +329,8 @@ def delete( class AsyncTemplatesResource(AsyncAPIResource): + """Manage message templates with variable substitution""" + @cached_property def with_raw_response(self) -> AsyncTemplatesResourceWithRawResponse: """ diff --git a/src/sent_dm/resources/users.py b/src/sent_dm/resources/users.py index 22486abd..7d4136bb 100644 --- a/src/sent_dm/resources/users.py +++ b/src/sent_dm/resources/users.py @@ -23,6 +23,8 @@ class UsersResource(SyncAPIResource): + """Invite, update, and manage organization users and roles""" + @cached_property def with_raw_response(self) -> UsersResourceWithRawResponse: """ @@ -262,6 +264,8 @@ def update_role( class AsyncUsersResource(AsyncAPIResource): + """Invite, update, and manage organization users and roles""" + @cached_property def with_raw_response(self) -> AsyncUsersResourceWithRawResponse: """ diff --git a/src/sent_dm/resources/webhooks.py b/src/sent_dm/resources/webhooks.py index c444a7ac..59ac131e 100644 --- a/src/sent_dm/resources/webhooks.py +++ b/src/sent_dm/resources/webhooks.py @@ -37,6 +37,8 @@ class WebhooksResource(SyncAPIResource): + """Configure webhook endpoints for real-time event delivery""" + @cached_property def with_raw_response(self) -> WebhooksResourceWithRawResponse: """ @@ -477,6 +479,8 @@ def toggle_status( class AsyncWebhooksResource(AsyncAPIResource): + """Configure webhook endpoints for real-time event delivery""" + @cached_property def with_raw_response(self) -> AsyncWebhooksResourceWithRawResponse: """ diff --git a/tests/api_resources/brands/test_campaigns.py b/tests/api_resources/brands/test_campaigns.py index 6c1b24d0..dd891730 100644 --- a/tests/api_resources/brands/test_campaigns.py +++ b/tests/api_resources/brands/test_campaigns.py @@ -20,7 +20,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: SentDm) -> None: campaign = client.brands.campaigns.create( @@ -42,7 +42,7 @@ def test_method_create(self, client: SentDm) -> None: ) assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: SentDm) -> None: campaign = client.brands.campaigns.create( @@ -75,7 +75,7 @@ def test_method_create_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: SentDm) -> None: response = client.brands.campaigns.with_raw_response.create( @@ -101,7 +101,7 @@ def test_raw_response_create(self, client: SentDm) -> None: campaign = response.parse() assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: SentDm) -> None: with client.brands.campaigns.with_streaming_response.create( @@ -129,7 +129,7 @@ def test_streaming_response_create(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -151,7 +151,7 @@ def test_path_params_create(self, client: SentDm) -> 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: SentDm) -> None: campaign = client.brands.campaigns.update( @@ -174,7 +174,7 @@ def test_method_update(self, client: SentDm) -> None: ) assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: SentDm) -> None: campaign = client.brands.campaigns.update( @@ -208,7 +208,7 @@ def test_method_update_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: SentDm) -> None: response = client.brands.campaigns.with_raw_response.update( @@ -235,7 +235,7 @@ def test_raw_response_update(self, client: SentDm) -> None: campaign = response.parse() assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: SentDm) -> None: with client.brands.campaigns.with_streaming_response.update( @@ -264,7 +264,7 @@ def test_streaming_response_update(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -307,7 +307,7 @@ def test_path_params_update(self, client: SentDm) -> 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: SentDm) -> None: campaign = client.brands.campaigns.list( @@ -315,7 +315,7 @@ def test_method_list(self, client: SentDm) -> None: ) assert_matches_type(CampaignListResponse, 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: SentDm) -> None: response = client.brands.campaigns.with_raw_response.list( @@ -327,7 +327,7 @@ def test_raw_response_list(self, client: SentDm) -> None: campaign = response.parse() assert_matches_type(CampaignListResponse, 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: SentDm) -> None: with client.brands.campaigns.with_streaming_response.list( @@ -341,7 +341,7 @@ def test_streaming_response_list(self, client: SentDm) -> 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_list(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -349,7 +349,7 @@ def test_path_params_list(self, client: SentDm) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete(self, client: SentDm) -> None: campaign = client.brands.campaigns.delete( @@ -359,7 +359,7 @@ def test_method_delete(self, client: SentDm) -> None: ) assert campaign is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete_with_all_params(self, client: SentDm) -> None: campaign = client.brands.campaigns.delete( @@ -369,7 +369,7 @@ def test_method_delete_with_all_params(self, client: SentDm) -> None: ) assert campaign is None - @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: SentDm) -> None: response = client.brands.campaigns.with_raw_response.delete( @@ -383,7 +383,7 @@ def test_raw_response_delete(self, client: SentDm) -> None: campaign = response.parse() assert campaign is None - @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: SentDm) -> None: with client.brands.campaigns.with_streaming_response.delete( @@ -399,7 +399,7 @@ def test_streaming_response_delete(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -422,7 +422,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: AsyncSentDm) -> None: campaign = await async_client.brands.campaigns.create( @@ -444,7 +444,7 @@ async def test_method_create(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: AsyncSentDm) -> None: campaign = await async_client.brands.campaigns.create( @@ -477,7 +477,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: AsyncSentDm) -> None: response = await async_client.brands.campaigns.with_raw_response.create( @@ -503,7 +503,7 @@ async def test_raw_response_create(self, async_client: AsyncSentDm) -> None: campaign = await response.parse() assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: AsyncSentDm) -> None: async with async_client.brands.campaigns.with_streaming_response.create( @@ -531,7 +531,7 @@ async def test_streaming_response_create(self, async_client: AsyncSentDm) -> 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_create(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -553,7 +553,7 @@ async def test_path_params_create(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: campaign = await async_client.brands.campaigns.update( @@ -576,7 +576,7 @@ async def test_method_update(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: AsyncSentDm) -> None: campaign = await async_client.brands.campaigns.update( @@ -610,7 +610,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: AsyncSentDm) -> None: response = await async_client.brands.campaigns.with_raw_response.update( @@ -637,7 +637,7 @@ async def test_raw_response_update(self, async_client: AsyncSentDm) -> None: campaign = await response.parse() assert_matches_type(APIResponseTcrCampaignWithUseCases, 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: AsyncSentDm) -> None: async with async_client.brands.campaigns.with_streaming_response.update( @@ -666,7 +666,7 @@ async def test_streaming_response_update(self, async_client: AsyncSentDm) -> 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_update(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -709,7 +709,7 @@ async def test_path_params_update(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: campaign = await async_client.brands.campaigns.list( @@ -717,7 +717,7 @@ async def test_method_list(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(CampaignListResponse, 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: AsyncSentDm) -> None: response = await async_client.brands.campaigns.with_raw_response.list( @@ -729,7 +729,7 @@ async def test_raw_response_list(self, async_client: AsyncSentDm) -> None: campaign = await response.parse() assert_matches_type(CampaignListResponse, 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: AsyncSentDm) -> None: async with async_client.brands.campaigns.with_streaming_response.list( @@ -743,7 +743,7 @@ async def test_streaming_response_list(self, async_client: AsyncSentDm) -> 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 async def test_path_params_list(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -751,7 +751,7 @@ async def test_path_params_list(self, async_client: AsyncSentDm) -> None: "", ) - @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: AsyncSentDm) -> None: campaign = await async_client.brands.campaigns.delete( @@ -761,7 +761,7 @@ async def test_method_delete(self, async_client: AsyncSentDm) -> None: ) assert campaign is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> None: campaign = await async_client.brands.campaigns.delete( @@ -771,7 +771,7 @@ async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> ) assert campaign is None - @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: AsyncSentDm) -> None: response = await async_client.brands.campaigns.with_raw_response.delete( @@ -785,7 +785,7 @@ async def test_raw_response_delete(self, async_client: AsyncSentDm) -> None: campaign = await response.parse() assert campaign is None - @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: AsyncSentDm) -> None: async with async_client.brands.campaigns.with_streaming_response.delete( @@ -801,7 +801,7 @@ async def test_streaming_response_delete(self, async_client: AsyncSentDm) -> 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_delete(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): diff --git a/tests/api_resources/test_brands.py b/tests/api_resources/test_brands.py index 0ee7e474..6b17fd45 100644 --- a/tests/api_resources/test_brands.py +++ b/tests/api_resources/test_brands.py @@ -20,7 +20,7 @@ class TestBrands: 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: SentDm) -> None: brand = client.brands.create( @@ -32,7 +32,7 @@ def test_method_create(self, client: SentDm) -> None: ) assert_matches_type(APIResponseBrandWithKYC, brand, 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: SentDm) -> None: brand = client.brands.create( @@ -74,7 +74,7 @@ def test_method_create_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseBrandWithKYC, brand, 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: SentDm) -> None: response = client.brands.with_raw_response.create( @@ -90,7 +90,7 @@ def test_raw_response_create(self, client: SentDm) -> None: brand = response.parse() assert_matches_type(APIResponseBrandWithKYC, brand, 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: SentDm) -> None: with client.brands.with_streaming_response.create( @@ -108,7 +108,7 @@ def test_streaming_response_create(self, client: SentDm) -> 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_update(self, client: SentDm) -> None: brand = client.brands.update( @@ -121,7 +121,7 @@ def test_method_update(self, client: SentDm) -> None: ) assert_matches_type(APIResponseBrandWithKYC, brand, 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: SentDm) -> None: brand = client.brands.update( @@ -164,7 +164,7 @@ def test_method_update_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseBrandWithKYC, brand, 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: SentDm) -> None: response = client.brands.with_raw_response.update( @@ -181,7 +181,7 @@ def test_raw_response_update(self, client: SentDm) -> None: brand = response.parse() assert_matches_type(APIResponseBrandWithKYC, brand, 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: SentDm) -> None: with client.brands.with_streaming_response.update( @@ -200,7 +200,7 @@ def test_streaming_response_update(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -213,13 +213,13 @@ def test_path_params_update(self, client: SentDm) -> 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: SentDm) -> None: brand = client.brands.list() assert_matches_type(BrandListResponse, brand, 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: SentDm) -> None: response = client.brands.with_raw_response.list() @@ -229,7 +229,7 @@ def test_raw_response_list(self, client: SentDm) -> None: brand = response.parse() assert_matches_type(BrandListResponse, brand, 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: SentDm) -> None: with client.brands.with_streaming_response.list() as response: @@ -241,7 +241,7 @@ def test_streaming_response_list(self, client: SentDm) -> 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: SentDm) -> None: brand = client.brands.delete( @@ -250,7 +250,7 @@ def test_method_delete(self, client: SentDm) -> None: ) assert brand is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete_with_all_params(self, client: SentDm) -> None: brand = client.brands.delete( @@ -259,7 +259,7 @@ def test_method_delete_with_all_params(self, client: SentDm) -> None: ) assert brand is None - @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: SentDm) -> None: response = client.brands.with_raw_response.delete( @@ -272,7 +272,7 @@ def test_raw_response_delete(self, client: SentDm) -> None: brand = response.parse() assert brand is None - @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: SentDm) -> None: with client.brands.with_streaming_response.delete( @@ -287,7 +287,7 @@ def test_streaming_response_delete(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -302,7 +302,7 @@ class TestAsyncBrands: "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: AsyncSentDm) -> None: brand = await async_client.brands.create( @@ -314,7 +314,7 @@ async def test_method_create(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseBrandWithKYC, brand, 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: AsyncSentDm) -> None: brand = await async_client.brands.create( @@ -356,7 +356,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseBrandWithKYC, brand, 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: AsyncSentDm) -> None: response = await async_client.brands.with_raw_response.create( @@ -372,7 +372,7 @@ async def test_raw_response_create(self, async_client: AsyncSentDm) -> None: brand = await response.parse() assert_matches_type(APIResponseBrandWithKYC, brand, 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: AsyncSentDm) -> None: async with async_client.brands.with_streaming_response.create( @@ -390,7 +390,7 @@ async def test_streaming_response_create(self, async_client: AsyncSentDm) -> 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_update(self, async_client: AsyncSentDm) -> None: brand = await async_client.brands.update( @@ -403,7 +403,7 @@ async def test_method_update(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseBrandWithKYC, brand, 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: AsyncSentDm) -> None: brand = await async_client.brands.update( @@ -446,7 +446,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseBrandWithKYC, brand, 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: AsyncSentDm) -> None: response = await async_client.brands.with_raw_response.update( @@ -463,7 +463,7 @@ async def test_raw_response_update(self, async_client: AsyncSentDm) -> None: brand = await response.parse() assert_matches_type(APIResponseBrandWithKYC, brand, 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: AsyncSentDm) -> None: async with async_client.brands.with_streaming_response.update( @@ -482,7 +482,7 @@ async def test_streaming_response_update(self, async_client: AsyncSentDm) -> 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_update(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): @@ -495,13 +495,13 @@ async def test_path_params_update(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: brand = await async_client.brands.list() assert_matches_type(BrandListResponse, brand, 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: AsyncSentDm) -> None: response = await async_client.brands.with_raw_response.list() @@ -511,7 +511,7 @@ async def test_raw_response_list(self, async_client: AsyncSentDm) -> None: brand = await response.parse() assert_matches_type(BrandListResponse, brand, 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: AsyncSentDm) -> None: async with async_client.brands.with_streaming_response.list() as response: @@ -523,7 +523,7 @@ async def test_streaming_response_list(self, async_client: AsyncSentDm) -> 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 async def test_method_delete(self, async_client: AsyncSentDm) -> None: brand = await async_client.brands.delete( @@ -532,7 +532,7 @@ async def test_method_delete(self, async_client: AsyncSentDm) -> None: ) assert brand is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> None: brand = await async_client.brands.delete( @@ -541,7 +541,7 @@ async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> ) assert brand is None - @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: AsyncSentDm) -> None: response = await async_client.brands.with_raw_response.delete( @@ -554,7 +554,7 @@ async def test_raw_response_delete(self, async_client: AsyncSentDm) -> None: brand = await response.parse() assert brand is None - @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: AsyncSentDm) -> None: async with async_client.brands.with_streaming_response.delete( @@ -569,7 +569,7 @@ async def test_streaming_response_delete(self, async_client: AsyncSentDm) -> 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_delete(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `brand_id` but received ''"): diff --git a/tests/api_resources/test_contacts.py b/tests/api_resources/test_contacts.py index a4107945..5a81eb6d 100644 --- a/tests/api_resources/test_contacts.py +++ b/tests/api_resources/test_contacts.py @@ -20,13 +20,13 @@ 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(self, client: SentDm) -> None: contact = client.contacts.create() assert_matches_type(APIResponseContact, 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(self, client: SentDm) -> None: contact = client.contacts.create( @@ -36,7 +36,7 @@ def test_method_create_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseContact, 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(self, client: SentDm) -> None: response = client.contacts.with_raw_response.create() @@ -46,7 +46,7 @@ def test_raw_response_create(self, client: SentDm) -> None: contact = response.parse() assert_matches_type(APIResponseContact, 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(self, client: SentDm) -> None: with client.contacts.with_streaming_response.create() as response: @@ -58,7 +58,7 @@ def test_streaming_response_create(self, client: SentDm) -> 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: SentDm) -> None: contact = client.contacts.retrieve( @@ -66,7 +66,7 @@ def test_method_retrieve(self, client: SentDm) -> None: ) assert_matches_type(APIResponseContact, 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: SentDm) -> None: response = client.contacts.with_raw_response.retrieve( @@ -78,7 +78,7 @@ def test_raw_response_retrieve(self, client: SentDm) -> None: contact = response.parse() assert_matches_type(APIResponseContact, 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: SentDm) -> None: with client.contacts.with_streaming_response.retrieve( @@ -92,7 +92,7 @@ def test_streaming_response_retrieve(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -100,7 +100,7 @@ def test_path_params_retrieve(self, client: SentDm) -> 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: SentDm) -> None: contact = client.contacts.update( @@ -108,7 +108,7 @@ def test_method_update(self, client: SentDm) -> None: ) assert_matches_type(APIResponseContact, contact, 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: SentDm) -> None: contact = client.contacts.update( @@ -120,7 +120,7 @@ def test_method_update_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseContact, 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_update(self, client: SentDm) -> None: response = client.contacts.with_raw_response.update( @@ -132,7 +132,7 @@ def test_raw_response_update(self, client: SentDm) -> None: contact = response.parse() assert_matches_type(APIResponseContact, 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_update(self, client: SentDm) -> None: with client.contacts.with_streaming_response.update( @@ -146,7 +146,7 @@ def test_streaming_response_update(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -154,7 +154,7 @@ def test_path_params_update(self, client: SentDm) -> 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: SentDm) -> None: contact = client.contacts.list( @@ -163,7 +163,7 @@ def test_method_list(self, client: SentDm) -> None: ) assert_matches_type(ContactListResponse, 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: SentDm) -> None: contact = client.contacts.list( @@ -175,7 +175,7 @@ def test_method_list_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(ContactListResponse, 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: SentDm) -> None: response = client.contacts.with_raw_response.list( @@ -188,7 +188,7 @@ def test_raw_response_list(self, client: SentDm) -> None: contact = response.parse() assert_matches_type(ContactListResponse, 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: SentDm) -> None: with client.contacts.with_streaming_response.list( @@ -203,7 +203,7 @@ def test_streaming_response_list(self, client: SentDm) -> 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: SentDm) -> None: contact = client.contacts.delete( @@ -212,7 +212,7 @@ def test_method_delete(self, client: SentDm) -> None: ) assert contact is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete_with_all_params(self, client: SentDm) -> None: contact = client.contacts.delete( @@ -221,7 +221,7 @@ def test_method_delete_with_all_params(self, client: SentDm) -> None: ) assert contact is None - @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: SentDm) -> None: response = client.contacts.with_raw_response.delete( @@ -234,7 +234,7 @@ def test_raw_response_delete(self, client: SentDm) -> None: contact = response.parse() assert contact is None - @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: SentDm) -> None: with client.contacts.with_streaming_response.delete( @@ -249,7 +249,7 @@ def test_streaming_response_delete(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -264,13 +264,13 @@ 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(self, async_client: AsyncSentDm) -> None: contact = await async_client.contacts.create() assert_matches_type(APIResponseContact, 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(self, async_client: AsyncSentDm) -> None: contact = await async_client.contacts.create( @@ -280,7 +280,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseContact, 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(self, async_client: AsyncSentDm) -> None: response = await async_client.contacts.with_raw_response.create() @@ -290,7 +290,7 @@ async def test_raw_response_create(self, async_client: AsyncSentDm) -> None: contact = await response.parse() assert_matches_type(APIResponseContact, 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(self, async_client: AsyncSentDm) -> None: async with async_client.contacts.with_streaming_response.create() as response: @@ -302,7 +302,7 @@ async def test_streaming_response_create(self, async_client: AsyncSentDm) -> 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(self, async_client: AsyncSentDm) -> None: contact = await async_client.contacts.retrieve( @@ -310,7 +310,7 @@ async def test_method_retrieve(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseContact, 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: AsyncSentDm) -> None: response = await async_client.contacts.with_raw_response.retrieve( @@ -322,7 +322,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncSentDm) -> None: contact = await response.parse() assert_matches_type(APIResponseContact, 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: AsyncSentDm) -> None: async with async_client.contacts.with_streaming_response.retrieve( @@ -336,7 +336,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncSentDm) -> 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_retrieve(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -344,7 +344,7 @@ async def test_path_params_retrieve(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: contact = await async_client.contacts.update( @@ -352,7 +352,7 @@ async def test_method_update(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseContact, 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_update_with_all_params(self, async_client: AsyncSentDm) -> None: contact = await async_client.contacts.update( @@ -364,7 +364,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseContact, 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_update(self, async_client: AsyncSentDm) -> None: response = await async_client.contacts.with_raw_response.update( @@ -376,7 +376,7 @@ async def test_raw_response_update(self, async_client: AsyncSentDm) -> None: contact = await response.parse() assert_matches_type(APIResponseContact, 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_update(self, async_client: AsyncSentDm) -> None: async with async_client.contacts.with_streaming_response.update( @@ -390,7 +390,7 @@ async def test_streaming_response_update(self, async_client: AsyncSentDm) -> 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_update(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -398,7 +398,7 @@ async def test_path_params_update(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: contact = await async_client.contacts.list( @@ -407,7 +407,7 @@ async def test_method_list(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(ContactListResponse, 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: AsyncSentDm) -> None: contact = await async_client.contacts.list( @@ -419,7 +419,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncSentDm) -> N ) assert_matches_type(ContactListResponse, 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: AsyncSentDm) -> None: response = await async_client.contacts.with_raw_response.list( @@ -432,7 +432,7 @@ async def test_raw_response_list(self, async_client: AsyncSentDm) -> None: contact = await response.parse() assert_matches_type(ContactListResponse, 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: AsyncSentDm) -> None: async with async_client.contacts.with_streaming_response.list( @@ -447,7 +447,7 @@ async def test_streaming_response_list(self, async_client: AsyncSentDm) -> 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 async def test_method_delete(self, async_client: AsyncSentDm) -> None: contact = await async_client.contacts.delete( @@ -456,7 +456,7 @@ async def test_method_delete(self, async_client: AsyncSentDm) -> None: ) assert contact is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> None: contact = await async_client.contacts.delete( @@ -465,7 +465,7 @@ async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> ) assert contact is None - @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: AsyncSentDm) -> None: response = await async_client.contacts.with_raw_response.delete( @@ -478,7 +478,7 @@ async def test_raw_response_delete(self, async_client: AsyncSentDm) -> None: contact = await response.parse() assert contact is None - @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: AsyncSentDm) -> None: async with async_client.contacts.with_streaming_response.delete( @@ -493,7 +493,7 @@ async def test_streaming_response_delete(self, async_client: AsyncSentDm) -> 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_delete(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/test_lookup.py b/tests/api_resources/test_lookup.py index 6b1e41ae..112ce0a1 100644 --- a/tests/api_resources/test_lookup.py +++ b/tests/api_resources/test_lookup.py @@ -17,7 +17,7 @@ class TestLookup: 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_phone_info(self, client: SentDm) -> None: lookup = client.lookup.retrieve_phone_info( @@ -25,7 +25,7 @@ def test_method_retrieve_phone_info(self, client: SentDm) -> None: ) assert_matches_type(LookupRetrievePhoneInfoResponse, lookup, 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_phone_info(self, client: SentDm) -> None: response = client.lookup.with_raw_response.retrieve_phone_info( @@ -37,7 +37,7 @@ def test_raw_response_retrieve_phone_info(self, client: SentDm) -> None: lookup = response.parse() assert_matches_type(LookupRetrievePhoneInfoResponse, lookup, 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_phone_info(self, client: SentDm) -> None: with client.lookup.with_streaming_response.retrieve_phone_info( @@ -51,7 +51,7 @@ def test_streaming_response_retrieve_phone_info(self, client: SentDm) -> 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_phone_info(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `phone_number` but received ''"): @@ -65,7 +65,7 @@ class TestAsyncLookup: "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_phone_info(self, async_client: AsyncSentDm) -> None: lookup = await async_client.lookup.retrieve_phone_info( @@ -73,7 +73,7 @@ async def test_method_retrieve_phone_info(self, async_client: AsyncSentDm) -> No ) assert_matches_type(LookupRetrievePhoneInfoResponse, lookup, 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_phone_info(self, async_client: AsyncSentDm) -> None: response = await async_client.lookup.with_raw_response.retrieve_phone_info( @@ -85,7 +85,7 @@ async def test_raw_response_retrieve_phone_info(self, async_client: AsyncSentDm) lookup = await response.parse() assert_matches_type(LookupRetrievePhoneInfoResponse, lookup, 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_phone_info(self, async_client: AsyncSentDm) -> None: async with async_client.lookup.with_streaming_response.retrieve_phone_info( @@ -99,7 +99,7 @@ async def test_streaming_response_retrieve_phone_info(self, async_client: AsyncS 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_phone_info(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `phone_number` but received ''"): diff --git a/tests/api_resources/test_me.py b/tests/api_resources/test_me.py index ed460270..0a4d9b0a 100644 --- a/tests/api_resources/test_me.py +++ b/tests/api_resources/test_me.py @@ -17,13 +17,13 @@ class TestMe: 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: SentDm) -> None: me = client.me.retrieve() assert_matches_type(MeRetrieveResponse, me, 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: SentDm) -> None: response = client.me.with_raw_response.retrieve() @@ -33,7 +33,7 @@ def test_raw_response_retrieve(self, client: SentDm) -> None: me = response.parse() assert_matches_type(MeRetrieveResponse, me, 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: SentDm) -> None: with client.me.with_streaming_response.retrieve() as response: @@ -51,13 +51,13 @@ class TestAsyncMe: "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: AsyncSentDm) -> None: me = await async_client.me.retrieve() assert_matches_type(MeRetrieveResponse, me, 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: AsyncSentDm) -> None: response = await async_client.me.with_raw_response.retrieve() @@ -67,7 +67,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncSentDm) -> None: me = await response.parse() assert_matches_type(MeRetrieveResponse, me, 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: AsyncSentDm) -> None: async with async_client.me.with_streaming_response.retrieve() as response: diff --git a/tests/api_resources/test_messages.py b/tests/api_resources/test_messages.py index 70246710..1e8c4bb6 100644 --- a/tests/api_resources/test_messages.py +++ b/tests/api_resources/test_messages.py @@ -21,7 +21,7 @@ class TestMessages: 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_activities(self, client: SentDm) -> None: message = client.messages.retrieve_activities( @@ -29,7 +29,7 @@ def test_method_retrieve_activities(self, client: SentDm) -> None: ) assert_matches_type(MessageRetrieveActivitiesResponse, message, 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_activities(self, client: SentDm) -> None: response = client.messages.with_raw_response.retrieve_activities( @@ -41,7 +41,7 @@ def test_raw_response_retrieve_activities(self, client: SentDm) -> None: message = response.parse() assert_matches_type(MessageRetrieveActivitiesResponse, message, 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_activities(self, client: SentDm) -> None: with client.messages.with_streaming_response.retrieve_activities( @@ -55,7 +55,7 @@ def test_streaming_response_retrieve_activities(self, client: SentDm) -> 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_activities(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -63,7 +63,7 @@ def test_path_params_retrieve_activities(self, client: SentDm) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_retrieve_status(self, client: SentDm) -> None: message = client.messages.retrieve_status( @@ -71,7 +71,7 @@ def test_method_retrieve_status(self, client: SentDm) -> None: ) assert_matches_type(MessageRetrieveStatusResponse, message, 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_status(self, client: SentDm) -> None: response = client.messages.with_raw_response.retrieve_status( @@ -83,7 +83,7 @@ def test_raw_response_retrieve_status(self, client: SentDm) -> None: message = response.parse() assert_matches_type(MessageRetrieveStatusResponse, message, 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_status(self, client: SentDm) -> None: with client.messages.with_streaming_response.retrieve_status( @@ -97,7 +97,7 @@ def test_streaming_response_retrieve_status(self, client: SentDm) -> 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_status(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -105,13 +105,13 @@ def test_path_params_retrieve_status(self, client: SentDm) -> 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: SentDm) -> None: message = client.messages.send() assert_matches_type(MessageSendResponse, message, 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: SentDm) -> None: message = client.messages.send( @@ -130,7 +130,7 @@ def test_method_send_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(MessageSendResponse, message, 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: SentDm) -> None: response = client.messages.with_raw_response.send() @@ -140,7 +140,7 @@ def test_raw_response_send(self, client: SentDm) -> None: message = response.parse() assert_matches_type(MessageSendResponse, message, 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: SentDm) -> None: with client.messages.with_streaming_response.send() as response: @@ -158,7 +158,7 @@ class TestAsyncMessages: "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_activities(self, async_client: AsyncSentDm) -> None: message = await async_client.messages.retrieve_activities( @@ -166,7 +166,7 @@ async def test_method_retrieve_activities(self, async_client: AsyncSentDm) -> No ) assert_matches_type(MessageRetrieveActivitiesResponse, message, 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_activities(self, async_client: AsyncSentDm) -> None: response = await async_client.messages.with_raw_response.retrieve_activities( @@ -178,7 +178,7 @@ async def test_raw_response_retrieve_activities(self, async_client: AsyncSentDm) message = await response.parse() assert_matches_type(MessageRetrieveActivitiesResponse, message, 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_activities(self, async_client: AsyncSentDm) -> None: async with async_client.messages.with_streaming_response.retrieve_activities( @@ -192,7 +192,7 @@ async def test_streaming_response_retrieve_activities(self, async_client: AsyncS 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_activities(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -200,7 +200,7 @@ async def test_path_params_retrieve_activities(self, async_client: AsyncSentDm) "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_retrieve_status(self, async_client: AsyncSentDm) -> None: message = await async_client.messages.retrieve_status( @@ -208,7 +208,7 @@ async def test_method_retrieve_status(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(MessageRetrieveStatusResponse, message, 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_status(self, async_client: AsyncSentDm) -> None: response = await async_client.messages.with_raw_response.retrieve_status( @@ -220,7 +220,7 @@ async def test_raw_response_retrieve_status(self, async_client: AsyncSentDm) -> message = await response.parse() assert_matches_type(MessageRetrieveStatusResponse, message, 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_status(self, async_client: AsyncSentDm) -> None: async with async_client.messages.with_streaming_response.retrieve_status( @@ -234,7 +234,7 @@ async def test_streaming_response_retrieve_status(self, async_client: AsyncSentD 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_status(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -242,13 +242,13 @@ async def test_path_params_retrieve_status(self, async_client: AsyncSentDm) -> N "", ) - @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: AsyncSentDm) -> None: message = await async_client.messages.send() assert_matches_type(MessageSendResponse, message, 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: AsyncSentDm) -> None: message = await async_client.messages.send( @@ -267,7 +267,7 @@ async def test_method_send_with_all_params(self, async_client: AsyncSentDm) -> N ) assert_matches_type(MessageSendResponse, message, 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: AsyncSentDm) -> None: response = await async_client.messages.with_raw_response.send() @@ -277,7 +277,7 @@ async def test_raw_response_send(self, async_client: AsyncSentDm) -> None: message = await response.parse() assert_matches_type(MessageSendResponse, message, 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: AsyncSentDm) -> None: async with async_client.messages.with_streaming_response.send() as response: diff --git a/tests/api_resources/test_profiles.py b/tests/api_resources/test_profiles.py index 4b7471f4..15a4fd28 100644 --- a/tests/api_resources/test_profiles.py +++ b/tests/api_resources/test_profiles.py @@ -20,13 +20,13 @@ class TestProfiles: 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: SentDm) -> None: profile = client.profiles.create() assert_matches_type(APIResponseOfProfileDetail, profile, 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: SentDm) -> None: profile = client.profiles.create( @@ -46,7 +46,7 @@ def test_method_create_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseOfProfileDetail, profile, 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: SentDm) -> None: response = client.profiles.with_raw_response.create() @@ -56,7 +56,7 @@ def test_raw_response_create(self, client: SentDm) -> None: profile = response.parse() assert_matches_type(APIResponseOfProfileDetail, profile, 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: SentDm) -> None: with client.profiles.with_streaming_response.create() as response: @@ -68,7 +68,7 @@ def test_streaming_response_create(self, client: SentDm) -> 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: SentDm) -> None: profile = client.profiles.retrieve( @@ -76,7 +76,7 @@ def test_method_retrieve(self, client: SentDm) -> None: ) assert_matches_type(APIResponseOfProfileDetail, profile, 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: SentDm) -> None: response = client.profiles.with_raw_response.retrieve( @@ -88,7 +88,7 @@ def test_raw_response_retrieve(self, client: SentDm) -> None: profile = response.parse() assert_matches_type(APIResponseOfProfileDetail, profile, 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: SentDm) -> None: with client.profiles.with_streaming_response.retrieve( @@ -102,7 +102,7 @@ def test_streaming_response_retrieve(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `profile_id` but received ''"): @@ -110,7 +110,7 @@ def test_path_params_retrieve(self, client: SentDm) -> 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: SentDm) -> None: profile = client.profiles.update( @@ -118,7 +118,7 @@ def test_method_update(self, client: SentDm) -> None: ) assert_matches_type(APIResponseOfProfileDetail, profile, 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: SentDm) -> None: profile = client.profiles.update( @@ -145,7 +145,7 @@ def test_method_update_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseOfProfileDetail, profile, 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: SentDm) -> None: response = client.profiles.with_raw_response.update( @@ -157,7 +157,7 @@ def test_raw_response_update(self, client: SentDm) -> None: profile = response.parse() assert_matches_type(APIResponseOfProfileDetail, profile, 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: SentDm) -> None: with client.profiles.with_streaming_response.update( @@ -171,7 +171,7 @@ def test_streaming_response_update(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_profile_id` but received ''"): @@ -179,13 +179,13 @@ def test_path_params_update(self, client: SentDm) -> None: path_profile_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: SentDm) -> None: profile = client.profiles.list() assert_matches_type(ProfileListResponse, profile, 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: SentDm) -> None: response = client.profiles.with_raw_response.list() @@ -195,7 +195,7 @@ def test_raw_response_list(self, client: SentDm) -> None: profile = response.parse() assert_matches_type(ProfileListResponse, profile, 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: SentDm) -> None: with client.profiles.with_streaming_response.list() as response: @@ -207,7 +207,7 @@ def test_streaming_response_list(self, client: SentDm) -> 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: SentDm) -> None: profile = client.profiles.delete( @@ -215,7 +215,7 @@ def test_method_delete(self, client: SentDm) -> None: ) assert profile is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete_with_all_params(self, client: SentDm) -> None: profile = client.profiles.delete( @@ -225,7 +225,7 @@ def test_method_delete_with_all_params(self, client: SentDm) -> None: ) assert profile is None - @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: SentDm) -> None: response = client.profiles.with_raw_response.delete( @@ -237,7 +237,7 @@ def test_raw_response_delete(self, client: SentDm) -> None: profile = response.parse() assert profile is None - @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: SentDm) -> None: with client.profiles.with_streaming_response.delete( @@ -251,7 +251,7 @@ def test_streaming_response_delete(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_profile_id` but received ''"): @@ -259,7 +259,7 @@ def test_path_params_delete(self, client: SentDm) -> None: path_profile_id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_complete(self, client: SentDm) -> None: profile = client.profiles.complete( @@ -268,7 +268,7 @@ def test_method_complete(self, client: SentDm) -> None: ) assert_matches_type(object, profile, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_complete_with_all_params(self, client: SentDm) -> None: profile = client.profiles.complete( @@ -279,7 +279,7 @@ def test_method_complete_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(object, profile, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_complete(self, client: SentDm) -> None: response = client.profiles.with_raw_response.complete( @@ -292,7 +292,7 @@ def test_raw_response_complete(self, client: SentDm) -> None: profile = response.parse() assert_matches_type(object, profile, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_complete(self, client: SentDm) -> None: with client.profiles.with_streaming_response.complete( @@ -307,7 +307,7 @@ def test_streaming_response_complete(self, client: SentDm) -> 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_complete(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `profile_id` but received ''"): @@ -322,13 +322,13 @@ class TestAsyncProfiles: "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: AsyncSentDm) -> None: profile = await async_client.profiles.create() assert_matches_type(APIResponseOfProfileDetail, profile, 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: AsyncSentDm) -> None: profile = await async_client.profiles.create( @@ -348,7 +348,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseOfProfileDetail, profile, 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: AsyncSentDm) -> None: response = await async_client.profiles.with_raw_response.create() @@ -358,7 +358,7 @@ async def test_raw_response_create(self, async_client: AsyncSentDm) -> None: profile = await response.parse() assert_matches_type(APIResponseOfProfileDetail, profile, 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: AsyncSentDm) -> None: async with async_client.profiles.with_streaming_response.create() as response: @@ -370,7 +370,7 @@ async def test_streaming_response_create(self, async_client: AsyncSentDm) -> 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(self, async_client: AsyncSentDm) -> None: profile = await async_client.profiles.retrieve( @@ -378,7 +378,7 @@ async def test_method_retrieve(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseOfProfileDetail, profile, 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: AsyncSentDm) -> None: response = await async_client.profiles.with_raw_response.retrieve( @@ -390,7 +390,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncSentDm) -> None: profile = await response.parse() assert_matches_type(APIResponseOfProfileDetail, profile, 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: AsyncSentDm) -> None: async with async_client.profiles.with_streaming_response.retrieve( @@ -404,7 +404,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncSentDm) -> 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_retrieve(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `profile_id` but received ''"): @@ -412,7 +412,7 @@ async def test_path_params_retrieve(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: profile = await async_client.profiles.update( @@ -420,7 +420,7 @@ async def test_method_update(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseOfProfileDetail, profile, 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: AsyncSentDm) -> None: profile = await async_client.profiles.update( @@ -447,7 +447,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseOfProfileDetail, profile, 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: AsyncSentDm) -> None: response = await async_client.profiles.with_raw_response.update( @@ -459,7 +459,7 @@ async def test_raw_response_update(self, async_client: AsyncSentDm) -> None: profile = await response.parse() assert_matches_type(APIResponseOfProfileDetail, profile, 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: AsyncSentDm) -> None: async with async_client.profiles.with_streaming_response.update( @@ -473,7 +473,7 @@ async def test_streaming_response_update(self, async_client: AsyncSentDm) -> 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_update(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_profile_id` but received ''"): @@ -481,13 +481,13 @@ async def test_path_params_update(self, async_client: AsyncSentDm) -> None: path_profile_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: AsyncSentDm) -> None: profile = await async_client.profiles.list() assert_matches_type(ProfileListResponse, profile, 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: AsyncSentDm) -> None: response = await async_client.profiles.with_raw_response.list() @@ -497,7 +497,7 @@ async def test_raw_response_list(self, async_client: AsyncSentDm) -> None: profile = await response.parse() assert_matches_type(ProfileListResponse, profile, 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: AsyncSentDm) -> None: async with async_client.profiles.with_streaming_response.list() as response: @@ -509,7 +509,7 @@ async def test_streaming_response_list(self, async_client: AsyncSentDm) -> 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 async def test_method_delete(self, async_client: AsyncSentDm) -> None: profile = await async_client.profiles.delete( @@ -517,7 +517,7 @@ async def test_method_delete(self, async_client: AsyncSentDm) -> None: ) assert profile is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> None: profile = await async_client.profiles.delete( @@ -527,7 +527,7 @@ async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> ) assert profile is None - @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: AsyncSentDm) -> None: response = await async_client.profiles.with_raw_response.delete( @@ -539,7 +539,7 @@ async def test_raw_response_delete(self, async_client: AsyncSentDm) -> None: profile = await response.parse() assert profile is None - @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: AsyncSentDm) -> None: async with async_client.profiles.with_streaming_response.delete( @@ -553,7 +553,7 @@ async def test_streaming_response_delete(self, async_client: AsyncSentDm) -> 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_delete(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_profile_id` but received ''"): @@ -561,7 +561,7 @@ async def test_path_params_delete(self, async_client: AsyncSentDm) -> None: path_profile_id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_complete(self, async_client: AsyncSentDm) -> None: profile = await async_client.profiles.complete( @@ -570,7 +570,7 @@ async def test_method_complete(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(object, profile, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_complete_with_all_params(self, async_client: AsyncSentDm) -> None: profile = await async_client.profiles.complete( @@ -581,7 +581,7 @@ async def test_method_complete_with_all_params(self, async_client: AsyncSentDm) ) assert_matches_type(object, profile, 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_complete(self, async_client: AsyncSentDm) -> None: response = await async_client.profiles.with_raw_response.complete( @@ -594,7 +594,7 @@ async def test_raw_response_complete(self, async_client: AsyncSentDm) -> None: profile = await response.parse() assert_matches_type(object, profile, 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_complete(self, async_client: AsyncSentDm) -> None: async with async_client.profiles.with_streaming_response.complete( @@ -609,7 +609,7 @@ async def test_streaming_response_complete(self, async_client: AsyncSentDm) -> 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_complete(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `profile_id` but received ''"): diff --git a/tests/api_resources/test_templates.py b/tests/api_resources/test_templates.py index a9f3948a..9b6d734f 100644 --- a/tests/api_resources/test_templates.py +++ b/tests/api_resources/test_templates.py @@ -20,13 +20,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: SentDm) -> None: template = client.templates.create() assert_matches_type(APIResponseTemplate, 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: SentDm) -> None: template = client.templates.create( @@ -176,7 +176,7 @@ def test_method_create_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseTemplate, 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: SentDm) -> None: response = client.templates.with_raw_response.create() @@ -186,7 +186,7 @@ def test_raw_response_create(self, client: SentDm) -> None: template = response.parse() assert_matches_type(APIResponseTemplate, 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: SentDm) -> None: with client.templates.with_streaming_response.create() as response: @@ -198,7 +198,7 @@ def test_streaming_response_create(self, client: SentDm) -> 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: SentDm) -> None: template = client.templates.retrieve( @@ -206,7 +206,7 @@ def test_method_retrieve(self, client: SentDm) -> None: ) assert_matches_type(APIResponseTemplate, 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: SentDm) -> None: response = client.templates.with_raw_response.retrieve( @@ -218,7 +218,7 @@ def test_raw_response_retrieve(self, client: SentDm) -> None: template = response.parse() assert_matches_type(APIResponseTemplate, 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: SentDm) -> None: with client.templates.with_streaming_response.retrieve( @@ -232,7 +232,7 @@ def test_streaming_response_retrieve(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -240,7 +240,7 @@ def test_path_params_retrieve(self, client: SentDm) -> 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: SentDm) -> None: template = client.templates.update( @@ -248,7 +248,7 @@ def test_method_update(self, client: SentDm) -> None: ) assert_matches_type(APIResponseTemplate, 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: SentDm) -> None: template = client.templates.update( @@ -386,7 +386,7 @@ def test_method_update_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseTemplate, 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: SentDm) -> None: response = client.templates.with_raw_response.update( @@ -398,7 +398,7 @@ def test_raw_response_update(self, client: SentDm) -> None: template = response.parse() assert_matches_type(APIResponseTemplate, 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: SentDm) -> None: with client.templates.with_streaming_response.update( @@ -412,7 +412,7 @@ def test_streaming_response_update(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -420,7 +420,7 @@ def test_path_params_update(self, client: SentDm) -> 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: SentDm) -> None: template = client.templates.list( @@ -429,7 +429,7 @@ def test_method_list(self, client: SentDm) -> None: ) assert_matches_type(TemplateListResponse, 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: SentDm) -> None: template = client.templates.list( @@ -441,7 +441,7 @@ def test_method_list_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(TemplateListResponse, 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: SentDm) -> None: response = client.templates.with_raw_response.list( @@ -454,7 +454,7 @@ def test_raw_response_list(self, client: SentDm) -> None: template = response.parse() assert_matches_type(TemplateListResponse, 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: SentDm) -> None: with client.templates.with_streaming_response.list( @@ -469,7 +469,7 @@ def test_streaming_response_list(self, client: SentDm) -> 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: SentDm) -> None: template = client.templates.delete( @@ -477,7 +477,7 @@ def test_method_delete(self, client: SentDm) -> None: ) assert template is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_delete_with_all_params(self, client: SentDm) -> None: template = client.templates.delete( @@ -487,7 +487,7 @@ def test_method_delete_with_all_params(self, client: SentDm) -> None: ) assert template is None - @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: SentDm) -> None: response = client.templates.with_raw_response.delete( @@ -499,7 +499,7 @@ def test_raw_response_delete(self, client: SentDm) -> None: template = response.parse() assert template is None - @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: SentDm) -> None: with client.templates.with_streaming_response.delete( @@ -513,7 +513,7 @@ def test_streaming_response_delete(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -527,13 +527,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: AsyncSentDm) -> None: template = await async_client.templates.create() assert_matches_type(APIResponseTemplate, 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: AsyncSentDm) -> None: template = await async_client.templates.create( @@ -683,7 +683,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseTemplate, 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: AsyncSentDm) -> None: response = await async_client.templates.with_raw_response.create() @@ -693,7 +693,7 @@ async def test_raw_response_create(self, async_client: AsyncSentDm) -> None: template = await response.parse() assert_matches_type(APIResponseTemplate, 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: AsyncSentDm) -> None: async with async_client.templates.with_streaming_response.create() as response: @@ -705,7 +705,7 @@ async def test_streaming_response_create(self, async_client: AsyncSentDm) -> 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(self, async_client: AsyncSentDm) -> None: template = await async_client.templates.retrieve( @@ -713,7 +713,7 @@ async def test_method_retrieve(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseTemplate, 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: AsyncSentDm) -> None: response = await async_client.templates.with_raw_response.retrieve( @@ -725,7 +725,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncSentDm) -> None: template = await response.parse() assert_matches_type(APIResponseTemplate, 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: AsyncSentDm) -> None: async with async_client.templates.with_streaming_response.retrieve( @@ -739,7 +739,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncSentDm) -> 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_retrieve(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -747,7 +747,7 @@ async def test_path_params_retrieve(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: template = await async_client.templates.update( @@ -755,7 +755,7 @@ async def test_method_update(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseTemplate, 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: AsyncSentDm) -> None: template = await async_client.templates.update( @@ -893,7 +893,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseTemplate, 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: AsyncSentDm) -> None: response = await async_client.templates.with_raw_response.update( @@ -905,7 +905,7 @@ async def test_raw_response_update(self, async_client: AsyncSentDm) -> None: template = await response.parse() assert_matches_type(APIResponseTemplate, 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: AsyncSentDm) -> None: async with async_client.templates.with_streaming_response.update( @@ -919,7 +919,7 @@ async def test_streaming_response_update(self, async_client: AsyncSentDm) -> 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_update(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -927,7 +927,7 @@ async def test_path_params_update(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: template = await async_client.templates.list( @@ -936,7 +936,7 @@ async def test_method_list(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(TemplateListResponse, 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: AsyncSentDm) -> None: template = await async_client.templates.list( @@ -948,7 +948,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncSentDm) -> N ) assert_matches_type(TemplateListResponse, 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: AsyncSentDm) -> None: response = await async_client.templates.with_raw_response.list( @@ -961,7 +961,7 @@ async def test_raw_response_list(self, async_client: AsyncSentDm) -> None: template = await response.parse() assert_matches_type(TemplateListResponse, 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: AsyncSentDm) -> None: async with async_client.templates.with_streaming_response.list( @@ -976,7 +976,7 @@ async def test_streaming_response_list(self, async_client: AsyncSentDm) -> 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 async def test_method_delete(self, async_client: AsyncSentDm) -> None: template = await async_client.templates.delete( @@ -984,7 +984,7 @@ async def test_method_delete(self, async_client: AsyncSentDm) -> None: ) assert template is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> None: template = await async_client.templates.delete( @@ -994,7 +994,7 @@ async def test_method_delete_with_all_params(self, async_client: AsyncSentDm) -> ) assert template is None - @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: AsyncSentDm) -> None: response = await async_client.templates.with_raw_response.delete( @@ -1006,7 +1006,7 @@ async def test_raw_response_delete(self, async_client: AsyncSentDm) -> None: template = await response.parse() assert template is None - @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: AsyncSentDm) -> None: async with async_client.templates.with_streaming_response.delete( @@ -1020,7 +1020,7 @@ async def test_streaming_response_delete(self, async_client: AsyncSentDm) -> 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_delete(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/api_resources/test_users.py b/tests/api_resources/test_users.py index dd111ca2..380d2716 100644 --- a/tests/api_resources/test_users.py +++ b/tests/api_resources/test_users.py @@ -20,7 +20,7 @@ class TestUsers: 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: SentDm) -> None: user = client.users.retrieve( @@ -28,7 +28,7 @@ def test_method_retrieve(self, client: SentDm) -> None: ) assert_matches_type(APIResponseOfUser, user, 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: SentDm) -> None: response = client.users.with_raw_response.retrieve( @@ -40,7 +40,7 @@ def test_raw_response_retrieve(self, client: SentDm) -> None: user = response.parse() assert_matches_type(APIResponseOfUser, user, 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: SentDm) -> None: with client.users.with_streaming_response.retrieve( @@ -54,7 +54,7 @@ def test_streaming_response_retrieve(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"): @@ -62,13 +62,13 @@ def test_path_params_retrieve(self, client: SentDm) -> 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: SentDm) -> None: user = client.users.list() assert_matches_type(UserListResponse, user, 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: SentDm) -> None: response = client.users.with_raw_response.list() @@ -78,7 +78,7 @@ def test_raw_response_list(self, client: SentDm) -> None: user = response.parse() assert_matches_type(UserListResponse, user, 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: SentDm) -> None: with client.users.with_streaming_response.list() as response: @@ -90,13 +90,13 @@ def test_streaming_response_list(self, client: SentDm) -> 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_invite(self, client: SentDm) -> None: user = client.users.invite() assert_matches_type(APIResponseOfUser, user, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_invite_with_all_params(self, client: SentDm) -> None: user = client.users.invite( @@ -108,7 +108,7 @@ def test_method_invite_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseOfUser, user, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_invite(self, client: SentDm) -> None: response = client.users.with_raw_response.invite() @@ -118,7 +118,7 @@ def test_raw_response_invite(self, client: SentDm) -> None: user = response.parse() assert_matches_type(APIResponseOfUser, user, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_invite(self, client: SentDm) -> None: with client.users.with_streaming_response.invite() as response: @@ -130,7 +130,7 @@ def test_streaming_response_invite(self, client: SentDm) -> 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_remove(self, client: SentDm) -> None: user = client.users.remove( @@ -138,7 +138,7 @@ def test_method_remove(self, client: SentDm) -> None: ) assert user is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_remove_with_all_params(self, client: SentDm) -> None: user = client.users.remove( @@ -148,7 +148,7 @@ def test_method_remove_with_all_params(self, client: SentDm) -> None: ) assert user is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_remove(self, client: SentDm) -> None: response = client.users.with_raw_response.remove( @@ -160,7 +160,7 @@ def test_raw_response_remove(self, client: SentDm) -> None: user = response.parse() assert user is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_remove(self, client: SentDm) -> None: with client.users.with_streaming_response.remove( @@ -174,7 +174,7 @@ def test_streaming_response_remove(self, client: SentDm) -> 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_remove(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_user_id` but received ''"): @@ -182,7 +182,7 @@ def test_path_params_remove(self, client: SentDm) -> None: path_user_id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_role(self, client: SentDm) -> None: user = client.users.update_role( @@ -190,7 +190,7 @@ def test_method_update_role(self, client: SentDm) -> None: ) assert_matches_type(APIResponseOfUser, user, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_update_role_with_all_params(self, client: SentDm) -> None: user = client.users.update_role( @@ -202,7 +202,7 @@ def test_method_update_role_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseOfUser, user, 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_role(self, client: SentDm) -> None: response = client.users.with_raw_response.update_role( @@ -214,7 +214,7 @@ def test_raw_response_update_role(self, client: SentDm) -> None: user = response.parse() assert_matches_type(APIResponseOfUser, user, 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_role(self, client: SentDm) -> None: with client.users.with_streaming_response.update_role( @@ -228,7 +228,7 @@ def test_streaming_response_update_role(self, client: SentDm) -> 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_role(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_user_id` but received ''"): @@ -242,7 +242,7 @@ class TestAsyncUsers: "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: AsyncSentDm) -> None: user = await async_client.users.retrieve( @@ -250,7 +250,7 @@ async def test_method_retrieve(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseOfUser, user, 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: AsyncSentDm) -> None: response = await async_client.users.with_raw_response.retrieve( @@ -262,7 +262,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncSentDm) -> None: user = await response.parse() assert_matches_type(APIResponseOfUser, user, 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: AsyncSentDm) -> None: async with async_client.users.with_streaming_response.retrieve( @@ -276,7 +276,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncSentDm) -> 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_retrieve(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `user_id` but received ''"): @@ -284,13 +284,13 @@ async def test_path_params_retrieve(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: user = await async_client.users.list() assert_matches_type(UserListResponse, user, 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: AsyncSentDm) -> None: response = await async_client.users.with_raw_response.list() @@ -300,7 +300,7 @@ async def test_raw_response_list(self, async_client: AsyncSentDm) -> None: user = await response.parse() assert_matches_type(UserListResponse, user, 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: AsyncSentDm) -> None: async with async_client.users.with_streaming_response.list() as response: @@ -312,13 +312,13 @@ async def test_streaming_response_list(self, async_client: AsyncSentDm) -> 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 async def test_method_invite(self, async_client: AsyncSentDm) -> None: user = await async_client.users.invite() assert_matches_type(APIResponseOfUser, user, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_invite_with_all_params(self, async_client: AsyncSentDm) -> None: user = await async_client.users.invite( @@ -330,7 +330,7 @@ async def test_method_invite_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseOfUser, user, 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_invite(self, async_client: AsyncSentDm) -> None: response = await async_client.users.with_raw_response.invite() @@ -340,7 +340,7 @@ async def test_raw_response_invite(self, async_client: AsyncSentDm) -> None: user = await response.parse() assert_matches_type(APIResponseOfUser, user, 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_invite(self, async_client: AsyncSentDm) -> None: async with async_client.users.with_streaming_response.invite() as response: @@ -352,7 +352,7 @@ async def test_streaming_response_invite(self, async_client: AsyncSentDm) -> 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_remove(self, async_client: AsyncSentDm) -> None: user = await async_client.users.remove( @@ -360,7 +360,7 @@ async def test_method_remove(self, async_client: AsyncSentDm) -> None: ) assert user is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_remove_with_all_params(self, async_client: AsyncSentDm) -> None: user = await async_client.users.remove( @@ -370,7 +370,7 @@ async def test_method_remove_with_all_params(self, async_client: AsyncSentDm) -> ) assert user is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_raw_response_remove(self, async_client: AsyncSentDm) -> None: response = await async_client.users.with_raw_response.remove( @@ -382,7 +382,7 @@ async def test_raw_response_remove(self, async_client: AsyncSentDm) -> None: user = await response.parse() assert user is None - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_streaming_response_remove(self, async_client: AsyncSentDm) -> None: async with async_client.users.with_streaming_response.remove( @@ -396,7 +396,7 @@ async def test_streaming_response_remove(self, async_client: AsyncSentDm) -> 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_remove(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_user_id` but received ''"): @@ -404,7 +404,7 @@ async def test_path_params_remove(self, async_client: AsyncSentDm) -> None: path_user_id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_update_role(self, async_client: AsyncSentDm) -> None: user = await async_client.users.update_role( @@ -412,7 +412,7 @@ async def test_method_update_role(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseOfUser, user, 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_role_with_all_params(self, async_client: AsyncSentDm) -> None: user = await async_client.users.update_role( @@ -424,7 +424,7 @@ async def test_method_update_role_with_all_params(self, async_client: AsyncSentD ) assert_matches_type(APIResponseOfUser, user, 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_role(self, async_client: AsyncSentDm) -> None: response = await async_client.users.with_raw_response.update_role( @@ -436,7 +436,7 @@ async def test_raw_response_update_role(self, async_client: AsyncSentDm) -> None user = await response.parse() assert_matches_type(APIResponseOfUser, user, 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_role(self, async_client: AsyncSentDm) -> None: async with async_client.users.with_streaming_response.update_role( @@ -450,7 +450,7 @@ async def test_streaming_response_update_role(self, async_client: AsyncSentDm) - 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_role(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `path_user_id` but received ''"): diff --git a/tests/api_resources/test_webhooks.py b/tests/api_resources/test_webhooks.py index f534f161..6340ac0b 100644 --- a/tests/api_resources/test_webhooks.py +++ b/tests/api_resources/test_webhooks.py @@ -24,13 +24,13 @@ class TestWebhooks: 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: SentDm) -> None: webhook = client.webhooks.create() assert_matches_type(APIResponseWebhook, webhook, 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: SentDm) -> None: webhook = client.webhooks.create( @@ -44,7 +44,7 @@ def test_method_create_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseWebhook, webhook, 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: SentDm) -> None: response = client.webhooks.with_raw_response.create() @@ -54,7 +54,7 @@ def test_raw_response_create(self, client: SentDm) -> None: webhook = response.parse() assert_matches_type(APIResponseWebhook, webhook, 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: SentDm) -> None: with client.webhooks.with_streaming_response.create() as response: @@ -66,7 +66,7 @@ def test_streaming_response_create(self, client: SentDm) -> 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: SentDm) -> None: webhook = client.webhooks.retrieve( @@ -74,7 +74,7 @@ def test_method_retrieve(self, client: SentDm) -> None: ) assert_matches_type(APIResponseWebhook, webhook, 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: SentDm) -> None: response = client.webhooks.with_raw_response.retrieve( @@ -86,7 +86,7 @@ def test_raw_response_retrieve(self, client: SentDm) -> None: webhook = response.parse() assert_matches_type(APIResponseWebhook, webhook, 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: SentDm) -> None: with client.webhooks.with_streaming_response.retrieve( @@ -100,7 +100,7 @@ def test_streaming_response_retrieve(self, client: SentDm) -> 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: SentDm) -> 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: SentDm) -> 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: SentDm) -> None: webhook = client.webhooks.update( @@ -116,7 +116,7 @@ def test_method_update(self, client: SentDm) -> None: ) assert_matches_type(APIResponseWebhook, webhook, 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: SentDm) -> None: webhook = client.webhooks.update( @@ -131,7 +131,7 @@ def test_method_update_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseWebhook, webhook, 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: SentDm) -> None: response = client.webhooks.with_raw_response.update( @@ -143,7 +143,7 @@ def test_raw_response_update(self, client: SentDm) -> None: webhook = response.parse() assert_matches_type(APIResponseWebhook, webhook, 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: SentDm) -> None: with client.webhooks.with_streaming_response.update( @@ -157,7 +157,7 @@ def test_streaming_response_update(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -165,7 +165,7 @@ def test_path_params_update(self, client: SentDm) -> 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: SentDm) -> None: webhook = client.webhooks.list( @@ -174,7 +174,7 @@ def test_method_list(self, client: SentDm) -> None: ) assert_matches_type(WebhookListResponse, webhook, 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: SentDm) -> None: webhook = client.webhooks.list( @@ -185,7 +185,7 @@ def test_method_list_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(WebhookListResponse, webhook, 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: SentDm) -> None: response = client.webhooks.with_raw_response.list( @@ -198,7 +198,7 @@ def test_raw_response_list(self, client: SentDm) -> None: webhook = response.parse() assert_matches_type(WebhookListResponse, webhook, 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: SentDm) -> None: with client.webhooks.with_streaming_response.list( @@ -213,7 +213,7 @@ def test_streaming_response_list(self, client: SentDm) -> 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: SentDm) -> None: webhook = client.webhooks.delete( @@ -221,7 +221,7 @@ def test_method_delete(self, client: SentDm) -> None: ) assert webhook is None - @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: SentDm) -> None: response = client.webhooks.with_raw_response.delete( @@ -233,7 +233,7 @@ def test_raw_response_delete(self, client: SentDm) -> None: webhook = response.parse() assert webhook is None - @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: SentDm) -> None: with client.webhooks.with_streaming_response.delete( @@ -247,7 +247,7 @@ def test_streaming_response_delete(self, client: SentDm) -> 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: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -255,13 +255,13 @@ def test_path_params_delete(self, client: SentDm) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_event_types(self, client: SentDm) -> None: webhook = client.webhooks.list_event_types() assert_matches_type(WebhookListEventTypesResponse, webhook, 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_event_types(self, client: SentDm) -> None: response = client.webhooks.with_raw_response.list_event_types() @@ -271,7 +271,7 @@ def test_raw_response_list_event_types(self, client: SentDm) -> None: webhook = response.parse() assert_matches_type(WebhookListEventTypesResponse, webhook, 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_event_types(self, client: SentDm) -> None: with client.webhooks.with_streaming_response.list_event_types() as response: @@ -283,7 +283,7 @@ def test_streaming_response_list_event_types(self, client: SentDm) -> 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_events(self, client: SentDm) -> None: webhook = client.webhooks.list_events( @@ -293,7 +293,7 @@ def test_method_list_events(self, client: SentDm) -> None: ) assert_matches_type(WebhookListEventsResponse, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_list_events_with_all_params(self, client: SentDm) -> None: webhook = client.webhooks.list_events( @@ -304,7 +304,7 @@ def test_method_list_events_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(WebhookListEventsResponse, webhook, 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_events(self, client: SentDm) -> None: response = client.webhooks.with_raw_response.list_events( @@ -318,7 +318,7 @@ def test_raw_response_list_events(self, client: SentDm) -> None: webhook = response.parse() assert_matches_type(WebhookListEventsResponse, webhook, 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_events(self, client: SentDm) -> None: with client.webhooks.with_streaming_response.list_events( @@ -334,7 +334,7 @@ def test_streaming_response_list_events(self, client: SentDm) -> 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_list_events(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -344,7 +344,7 @@ def test_path_params_list_events(self, client: SentDm) -> None: page_size=0, ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_rotate_secret(self, client: SentDm) -> None: webhook = client.webhooks.rotate_secret( @@ -353,7 +353,7 @@ def test_method_rotate_secret(self, client: SentDm) -> None: ) assert_matches_type(WebhookRotateSecretResponse, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_rotate_secret_with_all_params(self, client: SentDm) -> None: webhook = client.webhooks.rotate_secret( @@ -363,7 +363,7 @@ def test_method_rotate_secret_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(WebhookRotateSecretResponse, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_rotate_secret(self, client: SentDm) -> None: response = client.webhooks.with_raw_response.rotate_secret( @@ -376,7 +376,7 @@ def test_raw_response_rotate_secret(self, client: SentDm) -> None: webhook = response.parse() assert_matches_type(WebhookRotateSecretResponse, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_rotate_secret(self, client: SentDm) -> None: with client.webhooks.with_streaming_response.rotate_secret( @@ -391,7 +391,7 @@ def test_streaming_response_rotate_secret(self, client: SentDm) -> 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_rotate_secret(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -400,7 +400,7 @@ def test_path_params_rotate_secret(self, client: SentDm) -> None: body={}, ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_test(self, client: SentDm) -> None: webhook = client.webhooks.test( @@ -408,7 +408,7 @@ def test_method_test(self, client: SentDm) -> None: ) assert_matches_type(WebhookTestResponse, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_test_with_all_params(self, client: SentDm) -> None: webhook = client.webhooks.test( @@ -419,7 +419,7 @@ def test_method_test_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(WebhookTestResponse, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_test(self, client: SentDm) -> None: response = client.webhooks.with_raw_response.test( @@ -431,7 +431,7 @@ def test_raw_response_test(self, client: SentDm) -> None: webhook = response.parse() assert_matches_type(WebhookTestResponse, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_test(self, client: SentDm) -> None: with client.webhooks.with_streaming_response.test( @@ -445,7 +445,7 @@ def test_streaming_response_test(self, client: SentDm) -> 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_test(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -453,7 +453,7 @@ def test_path_params_test(self, client: SentDm) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_toggle_status(self, client: SentDm) -> None: webhook = client.webhooks.toggle_status( @@ -461,7 +461,7 @@ def test_method_toggle_status(self, client: SentDm) -> None: ) assert_matches_type(APIResponseWebhook, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_method_toggle_status_with_all_params(self, client: SentDm) -> None: webhook = client.webhooks.toggle_status( @@ -472,7 +472,7 @@ def test_method_toggle_status_with_all_params(self, client: SentDm) -> None: ) assert_matches_type(APIResponseWebhook, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_raw_response_toggle_status(self, client: SentDm) -> None: response = client.webhooks.with_raw_response.toggle_status( @@ -484,7 +484,7 @@ def test_raw_response_toggle_status(self, client: SentDm) -> None: webhook = response.parse() assert_matches_type(APIResponseWebhook, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize def test_streaming_response_toggle_status(self, client: SentDm) -> None: with client.webhooks.with_streaming_response.toggle_status( @@ -498,7 +498,7 @@ def test_streaming_response_toggle_status(self, client: SentDm) -> 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_toggle_status(self, client: SentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -512,13 +512,13 @@ class TestAsyncWebhooks: "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: AsyncSentDm) -> None: webhook = await async_client.webhooks.create() assert_matches_type(APIResponseWebhook, webhook, 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: AsyncSentDm) -> None: webhook = await async_client.webhooks.create( @@ -532,7 +532,7 @@ async def test_method_create_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseWebhook, webhook, 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: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.create() @@ -542,7 +542,7 @@ async def test_raw_response_create(self, async_client: AsyncSentDm) -> None: webhook = await response.parse() assert_matches_type(APIResponseWebhook, webhook, 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: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.create() as response: @@ -554,7 +554,7 @@ async def test_streaming_response_create(self, async_client: AsyncSentDm) -> 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(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.retrieve( @@ -562,7 +562,7 @@ async def test_method_retrieve(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseWebhook, webhook, 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: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.retrieve( @@ -574,7 +574,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncSentDm) -> None: webhook = await response.parse() assert_matches_type(APIResponseWebhook, webhook, 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: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.retrieve( @@ -588,7 +588,7 @@ async def test_streaming_response_retrieve(self, async_client: AsyncSentDm) -> 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_retrieve(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -596,7 +596,7 @@ async def test_path_params_retrieve(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: webhook = await async_client.webhooks.update( @@ -604,7 +604,7 @@ async def test_method_update(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseWebhook, webhook, 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: AsyncSentDm) -> None: webhook = await async_client.webhooks.update( @@ -619,7 +619,7 @@ async def test_method_update_with_all_params(self, async_client: AsyncSentDm) -> ) assert_matches_type(APIResponseWebhook, webhook, 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: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.update( @@ -631,7 +631,7 @@ async def test_raw_response_update(self, async_client: AsyncSentDm) -> None: webhook = await response.parse() assert_matches_type(APIResponseWebhook, webhook, 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: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.update( @@ -645,7 +645,7 @@ async def test_streaming_response_update(self, async_client: AsyncSentDm) -> 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_update(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -653,7 +653,7 @@ async def test_path_params_update(self, async_client: AsyncSentDm) -> 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: AsyncSentDm) -> None: webhook = await async_client.webhooks.list( @@ -662,7 +662,7 @@ async def test_method_list(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(WebhookListResponse, webhook, 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: AsyncSentDm) -> None: webhook = await async_client.webhooks.list( @@ -673,7 +673,7 @@ async def test_method_list_with_all_params(self, async_client: AsyncSentDm) -> N ) assert_matches_type(WebhookListResponse, webhook, 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: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.list( @@ -686,7 +686,7 @@ async def test_raw_response_list(self, async_client: AsyncSentDm) -> None: webhook = await response.parse() assert_matches_type(WebhookListResponse, webhook, 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: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.list( @@ -701,7 +701,7 @@ async def test_streaming_response_list(self, async_client: AsyncSentDm) -> 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 async def test_method_delete(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.delete( @@ -709,7 +709,7 @@ async def test_method_delete(self, async_client: AsyncSentDm) -> None: ) assert webhook is None - @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: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.delete( @@ -721,7 +721,7 @@ async def test_raw_response_delete(self, async_client: AsyncSentDm) -> None: webhook = await response.parse() assert webhook is None - @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: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.delete( @@ -735,7 +735,7 @@ async def test_streaming_response_delete(self, async_client: AsyncSentDm) -> 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_delete(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -743,13 +743,13 @@ async def test_path_params_delete(self, async_client: AsyncSentDm) -> None: "", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_list_event_types(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.list_event_types() assert_matches_type(WebhookListEventTypesResponse, webhook, 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_event_types(self, async_client: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.list_event_types() @@ -759,7 +759,7 @@ async def test_raw_response_list_event_types(self, async_client: AsyncSentDm) -> webhook = await response.parse() assert_matches_type(WebhookListEventTypesResponse, webhook, 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_event_types(self, async_client: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.list_event_types() as response: @@ -771,7 +771,7 @@ async def test_streaming_response_list_event_types(self, async_client: AsyncSent 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_events(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.list_events( @@ -781,7 +781,7 @@ async def test_method_list_events(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(WebhookListEventsResponse, webhook, 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_events_with_all_params(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.list_events( @@ -792,7 +792,7 @@ async def test_method_list_events_with_all_params(self, async_client: AsyncSentD ) assert_matches_type(WebhookListEventsResponse, webhook, 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_events(self, async_client: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.list_events( @@ -806,7 +806,7 @@ async def test_raw_response_list_events(self, async_client: AsyncSentDm) -> None webhook = await response.parse() assert_matches_type(WebhookListEventsResponse, webhook, 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_events(self, async_client: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.list_events( @@ -822,7 +822,7 @@ async def test_streaming_response_list_events(self, async_client: AsyncSentDm) - 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_list_events(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -832,7 +832,7 @@ async def test_path_params_list_events(self, async_client: AsyncSentDm) -> None: page_size=0, ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_rotate_secret(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.rotate_secret( @@ -841,7 +841,7 @@ async def test_method_rotate_secret(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(WebhookRotateSecretResponse, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_rotate_secret_with_all_params(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.rotate_secret( @@ -851,7 +851,7 @@ async def test_method_rotate_secret_with_all_params(self, async_client: AsyncSen ) assert_matches_type(WebhookRotateSecretResponse, webhook, 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_rotate_secret(self, async_client: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.rotate_secret( @@ -864,7 +864,7 @@ async def test_raw_response_rotate_secret(self, async_client: AsyncSentDm) -> No webhook = await response.parse() assert_matches_type(WebhookRotateSecretResponse, webhook, 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_rotate_secret(self, async_client: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.rotate_secret( @@ -879,7 +879,7 @@ async def test_streaming_response_rotate_secret(self, async_client: AsyncSentDm) 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_rotate_secret(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -888,7 +888,7 @@ async def test_path_params_rotate_secret(self, async_client: AsyncSentDm) -> Non body={}, ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_test(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.test( @@ -896,7 +896,7 @@ async def test_method_test(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(WebhookTestResponse, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_test_with_all_params(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.test( @@ -907,7 +907,7 @@ async def test_method_test_with_all_params(self, async_client: AsyncSentDm) -> N ) assert_matches_type(WebhookTestResponse, webhook, 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_test(self, async_client: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.test( @@ -919,7 +919,7 @@ async def test_raw_response_test(self, async_client: AsyncSentDm) -> None: webhook = await response.parse() assert_matches_type(WebhookTestResponse, webhook, 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_test(self, async_client: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.test( @@ -933,7 +933,7 @@ async def test_streaming_response_test(self, async_client: AsyncSentDm) -> 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 async def test_path_params_test(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): @@ -941,7 +941,7 @@ async def test_path_params_test(self, async_client: AsyncSentDm) -> None: id="", ) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_toggle_status(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.toggle_status( @@ -949,7 +949,7 @@ async def test_method_toggle_status(self, async_client: AsyncSentDm) -> None: ) assert_matches_type(APIResponseWebhook, webhook, path=["response"]) - @pytest.mark.skip(reason="Prism tests are disabled") + @pytest.mark.skip(reason="Mock server tests are disabled") @parametrize async def test_method_toggle_status_with_all_params(self, async_client: AsyncSentDm) -> None: webhook = await async_client.webhooks.toggle_status( @@ -960,7 +960,7 @@ async def test_method_toggle_status_with_all_params(self, async_client: AsyncSen ) assert_matches_type(APIResponseWebhook, webhook, 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_toggle_status(self, async_client: AsyncSentDm) -> None: response = await async_client.webhooks.with_raw_response.toggle_status( @@ -972,7 +972,7 @@ async def test_raw_response_toggle_status(self, async_client: AsyncSentDm) -> No webhook = await response.parse() assert_matches_type(APIResponseWebhook, webhook, 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_toggle_status(self, async_client: AsyncSentDm) -> None: async with async_client.webhooks.with_streaming_response.toggle_status( @@ -986,7 +986,7 @@ async def test_streaming_response_toggle_status(self, async_client: AsyncSentDm) 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_toggle_status(self, async_client: AsyncSentDm) -> None: with pytest.raises(ValueError, match=r"Expected a non-empty value for `id` but received ''"): diff --git a/tests/test_client.py b/tests/test_client.py index f5c5f5d0..3de3d541 100644 --- a/tests/test_client.py +++ b/tests/test_client.py @@ -945,6 +945,14 @@ def retry_handler(_request: httpx.Request) -> httpx.Response: def test_proxy_environment_variables(self, monkeypatch: pytest.MonkeyPatch) -> None: # Test that the proxy environment variables are set correctly monkeypatch.setenv("HTTPS_PROXY", "https://example.org") + # Delete in case our environment has any proxy env vars set + monkeypatch.delenv("HTTP_PROXY", raising=False) + monkeypatch.delenv("ALL_PROXY", raising=False) + monkeypatch.delenv("NO_PROXY", raising=False) + monkeypatch.delenv("http_proxy", raising=False) + monkeypatch.delenv("https_proxy", raising=False) + monkeypatch.delenv("all_proxy", raising=False) + monkeypatch.delenv("no_proxy", raising=False) client = DefaultHttpxClient() @@ -1847,6 +1855,14 @@ async def test_get_platform(self) -> None: async def test_proxy_environment_variables(self, monkeypatch: pytest.MonkeyPatch) -> None: # Test that the proxy environment variables are set correctly monkeypatch.setenv("HTTPS_PROXY", "https://example.org") + # Delete in case our environment has any proxy env vars set + monkeypatch.delenv("HTTP_PROXY", raising=False) + monkeypatch.delenv("ALL_PROXY", raising=False) + monkeypatch.delenv("NO_PROXY", raising=False) + monkeypatch.delenv("http_proxy", raising=False) + monkeypatch.delenv("https_proxy", raising=False) + monkeypatch.delenv("all_proxy", raising=False) + monkeypatch.delenv("no_proxy", raising=False) client = DefaultAsyncHttpxClient()