chore: improve example values

Author: stainless-app[bot]

tests/api_resources/phone_numbers/test_jobs.py

@@ -199,7 +199,7 @@ def test_method_update_batch_with_all_params(self, client: Telnyx) -> None:
                     "t38_fax_gateway_enabled": True,
                 },
                 "tech_prefix_enabled": True,
-                "translated_number": "translated_number",
+                "translated_number": "+13035559999",
                 "usage_payment_method": "pay-per-minute",
             },
         )
@@ -460,7 +460,7 @@ async def test_method_update_batch_with_all_params(self, async_client: AsyncTeln
                     "t38_fax_gateway_enabled": True,
                 },
                 "tech_prefix_enabled": True,
-                "translated_number": "translated_number",
+                "translated_number": "+13035559999",
                 "usage_payment_method": "pay-per-minute",
             },
         )

tests/api_resources/phone_numbers/test_voicemail.py

@@ -77,15 +77,15 @@ def test_path_params_create(self, client: Telnyx) -> None:
     @parametrize
     def test_method_retrieve(self, client: Telnyx) -> None:
         voicemail = client.phone_numbers.voicemail.retrieve(
-            "phone_number_id",
+            "123455678900",
         )
         assert_matches_type(VoicemailRetrieveResponse, voicemail, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Telnyx) -> None:
         response = client.phone_numbers.voicemail.with_raw_response.retrieve(
-            "phone_number_id",
+            "123455678900",
         )
 
         assert response.is_closed is True
@@ -97,7 +97,7 @@ def test_raw_response_retrieve(self, client: Telnyx) -> None:
     @parametrize
     def test_streaming_response_retrieve(self, client: Telnyx) -> None:
         with client.phone_numbers.voicemail.with_streaming_response.retrieve(
-            "phone_number_id",
+            "123455678900",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -229,15 +229,15 @@ async def test_path_params_create(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncTelnyx) -> None:
         voicemail = await async_client.phone_numbers.voicemail.retrieve(
-            "phone_number_id",
+            "123455678900",
         )
         assert_matches_type(VoicemailRetrieveResponse, voicemail, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncTelnyx) -> None:
         response = await async_client.phone_numbers.voicemail.with_raw_response.retrieve(
-            "phone_number_id",
+            "123455678900",
         )
 
         assert response.is_closed is True
@@ -249,7 +249,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncTelnyx) -> None:
         async with async_client.phone_numbers.voicemail.with_streaming_response.retrieve(
-            "phone_number_id",
+            "123455678900",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"

tests/api_resources/storage/buckets/test_ssl_certificate.py

@@ -77,15 +77,15 @@ def test_path_params_create(self, client: Telnyx) -> None:
     @parametrize
     def test_method_retrieve(self, client: Telnyx) -> None:
         ssl_certificate = client.storage.buckets.ssl_certificate.retrieve(
-            "bucketName",
+            "",
         )
         assert_matches_type(SslCertificateRetrieveResponse, ssl_certificate, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Telnyx) -> None:
         response = client.storage.buckets.ssl_certificate.with_raw_response.retrieve(
-            "bucketName",
+            "",
         )
 
         assert response.is_closed is True
@@ -97,7 +97,7 @@ def test_raw_response_retrieve(self, client: Telnyx) -> None:
     @parametrize
     def test_streaming_response_retrieve(self, client: Telnyx) -> None:
         with client.storage.buckets.ssl_certificate.with_streaming_response.retrieve(
-            "bucketName",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -119,15 +119,15 @@ def test_path_params_retrieve(self, client: Telnyx) -> None:
     @parametrize
     def test_method_delete(self, client: Telnyx) -> None:
         ssl_certificate = client.storage.buckets.ssl_certificate.delete(
-            "bucketName",
+            "",
         )
         assert_matches_type(SslCertificateDeleteResponse, ssl_certificate, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Telnyx) -> None:
         response = client.storage.buckets.ssl_certificate.with_raw_response.delete(
-            "bucketName",
+            "",
         )
 
         assert response.is_closed is True
@@ -139,7 +139,7 @@ def test_raw_response_delete(self, client: Telnyx) -> None:
     @parametrize
     def test_streaming_response_delete(self, client: Telnyx) -> None:
         with client.storage.buckets.ssl_certificate.with_streaming_response.delete(
-            "bucketName",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -219,15 +219,15 @@ async def test_path_params_create(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncTelnyx) -> None:
         ssl_certificate = await async_client.storage.buckets.ssl_certificate.retrieve(
-            "bucketName",
+            "",
         )
         assert_matches_type(SslCertificateRetrieveResponse, ssl_certificate, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncTelnyx) -> None:
         response = await async_client.storage.buckets.ssl_certificate.with_raw_response.retrieve(
-            "bucketName",
+            "",
         )
 
         assert response.is_closed is True
@@ -239,7 +239,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncTelnyx) -> None:
         async with async_client.storage.buckets.ssl_certificate.with_streaming_response.retrieve(
-            "bucketName",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -261,15 +261,15 @@ async def test_path_params_retrieve(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_method_delete(self, async_client: AsyncTelnyx) -> None:
         ssl_certificate = await async_client.storage.buckets.ssl_certificate.delete(
-            "bucketName",
+            "",
         )
         assert_matches_type(SslCertificateDeleteResponse, ssl_certificate, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncTelnyx) -> None:
         response = await async_client.storage.buckets.ssl_certificate.with_raw_response.delete(
-            "bucketName",
+            "",
         )
 
         assert response.is_closed is True
@@ -281,7 +281,7 @@ async def test_raw_response_delete(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncTelnyx) -> None:
         async with async_client.storage.buckets.ssl_certificate.with_streaming_response.delete(
-            "bucketName",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"

tests/api_resources/storage/buckets/test_usage.py

@@ -83,15 +83,15 @@ def test_path_params_get_api_usage(self, client: Telnyx) -> None:
     @parametrize
     def test_method_get_bucket_usage(self, client: Telnyx) -> None:
         usage = client.storage.buckets.usage.get_bucket_usage(
-            "bucketName",
+            "",
         )
         assert_matches_type(UsageGetBucketUsageResponse, usage, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_get_bucket_usage(self, client: Telnyx) -> None:
         response = client.storage.buckets.usage.with_raw_response.get_bucket_usage(
-            "bucketName",
+            "",
         )
 
         assert response.is_closed is True
@@ -103,7 +103,7 @@ def test_raw_response_get_bucket_usage(self, client: Telnyx) -> None:
     @parametrize
     def test_streaming_response_get_bucket_usage(self, client: Telnyx) -> None:
         with client.storage.buckets.usage.with_streaming_response.get_bucket_usage(
-            "bucketName",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -189,15 +189,15 @@ async def test_path_params_get_api_usage(self, async_client: AsyncTelnyx) -> Non
     @parametrize
     async def test_method_get_bucket_usage(self, async_client: AsyncTelnyx) -> None:
         usage = await async_client.storage.buckets.usage.get_bucket_usage(
-            "bucketName",
+            "",
         )
         assert_matches_type(UsageGetBucketUsageResponse, usage, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_get_bucket_usage(self, async_client: AsyncTelnyx) -> None:
         response = await async_client.storage.buckets.usage.with_raw_response.get_bucket_usage(
-            "bucketName",
+            "",
         )
 
         assert response.is_closed is True
@@ -209,7 +209,7 @@ async def test_raw_response_get_bucket_usage(self, async_client: AsyncTelnyx) ->
     @parametrize
     async def test_streaming_response_get_bucket_usage(self, async_client: AsyncTelnyx) -> None:
         async with async_client.storage.buckets.usage.with_streaming_response.get_bucket_usage(
-            "bucketName",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"

tests/api_resources/storage/migrations/test_actions.py

@@ -21,15 +21,15 @@ class TestActions:
     @parametrize
     def test_method_stop(self, client: Telnyx) -> None:
         action = client.storage.migrations.actions.stop(
-            "id",
+            "",
         )
         assert_matches_type(ActionStopResponse, action, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_stop(self, client: Telnyx) -> None:
         response = client.storage.migrations.actions.with_raw_response.stop(
-            "id",
+            "",
         )
 
         assert response.is_closed is True
@@ -41,7 +41,7 @@ def test_raw_response_stop(self, client: Telnyx) -> None:
     @parametrize
     def test_streaming_response_stop(self, client: Telnyx) -> None:
         with client.storage.migrations.actions.with_streaming_response.stop(
-            "id",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -69,15 +69,15 @@ class TestAsyncActions:
     @parametrize
     async def test_method_stop(self, async_client: AsyncTelnyx) -> None:
         action = await async_client.storage.migrations.actions.stop(
-            "id",
+            "",
         )
         assert_matches_type(ActionStopResponse, action, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_stop(self, async_client: AsyncTelnyx) -> None:
         response = await async_client.storage.migrations.actions.with_raw_response.stop(
-            "id",
+            "",
         )
 
         assert response.is_closed is True
@@ -89,7 +89,7 @@ async def test_raw_response_stop(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_streaming_response_stop(self, async_client: AsyncTelnyx) -> None:
         async with async_client.storage.migrations.actions.with_streaming_response.stop(
-            "id",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"

tests/api_resources/storage/test_migration_sources.py

@@ -80,15 +80,15 @@ def test_streaming_response_create(self, client: Telnyx) -> None:
     @parametrize
     def test_method_retrieve(self, client: Telnyx) -> None:
         migration_source = client.storage.migration_sources.retrieve(
-            "id",
+            "",
         )
         assert_matches_type(MigrationSourceRetrieveResponse, migration_source, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_retrieve(self, client: Telnyx) -> None:
         response = client.storage.migration_sources.with_raw_response.retrieve(
-            "id",
+            "",
         )
 
         assert response.is_closed is True
@@ -100,7 +100,7 @@ def test_raw_response_retrieve(self, client: Telnyx) -> None:
     @parametrize
     def test_streaming_response_retrieve(self, client: Telnyx) -> None:
         with client.storage.migration_sources.with_streaming_response.retrieve(
-            "id",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -150,15 +150,15 @@ def test_streaming_response_list(self, client: Telnyx) -> None:
     @parametrize
     def test_method_delete(self, client: Telnyx) -> None:
         migration_source = client.storage.migration_sources.delete(
-            "id",
+            "",
         )
         assert_matches_type(MigrationSourceDeleteResponse, migration_source, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     def test_raw_response_delete(self, client: Telnyx) -> None:
         response = client.storage.migration_sources.with_raw_response.delete(
-            "id",
+            "",
         )
 
         assert response.is_closed is True
@@ -170,7 +170,7 @@ def test_raw_response_delete(self, client: Telnyx) -> None:
     @parametrize
     def test_streaming_response_delete(self, client: Telnyx) -> None:
         with client.storage.migration_sources.with_streaming_response.delete(
-            "id",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -252,15 +252,15 @@ async def test_streaming_response_create(self, async_client: AsyncTelnyx) -> Non
     @parametrize
     async def test_method_retrieve(self, async_client: AsyncTelnyx) -> None:
         migration_source = await async_client.storage.migration_sources.retrieve(
-            "id",
+            "",
         )
         assert_matches_type(MigrationSourceRetrieveResponse, migration_source, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_retrieve(self, async_client: AsyncTelnyx) -> None:
         response = await async_client.storage.migration_sources.with_raw_response.retrieve(
-            "id",
+            "",
         )
 
         assert response.is_closed is True
@@ -272,7 +272,7 @@ async def test_raw_response_retrieve(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_streaming_response_retrieve(self, async_client: AsyncTelnyx) -> None:
         async with async_client.storage.migration_sources.with_streaming_response.retrieve(
-            "id",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"
@@ -322,15 +322,15 @@ async def test_streaming_response_list(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_method_delete(self, async_client: AsyncTelnyx) -> None:
         migration_source = await async_client.storage.migration_sources.delete(
-            "id",
+            "",
         )
         assert_matches_type(MigrationSourceDeleteResponse, migration_source, path=["response"])
 
     @pytest.mark.skip(reason="Prism tests are disabled")
     @parametrize
     async def test_raw_response_delete(self, async_client: AsyncTelnyx) -> None:
         response = await async_client.storage.migration_sources.with_raw_response.delete(
-            "id",
+            "",
         )
 
         assert response.is_closed is True
@@ -342,7 +342,7 @@ async def test_raw_response_delete(self, async_client: AsyncTelnyx) -> None:
     @parametrize
     async def test_streaming_response_delete(self, async_client: AsyncTelnyx) -> None:
         async with async_client.storage.migration_sources.with_streaming_response.delete(
-            "id",
+            "",
         ) as response:
             assert not response.is_closed
             assert response.http_request.headers.get("X-Stainless-Lang") == "python"