test(openai): Add tests for choices=None guard in OpenAI integration

Covers non-streaming, sync streaming, async streaming, and unit-level
token usage calculation to verify no crash when a provider returns
choices=None (e.g. OpenRouter upstream error responses).

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: patcherai-opensource-internal[bot]

tests/integrations/openai/test_openai.py

@@ -2388,6 +2388,189 @@ def count_tokens(msg):
         )
 
 
+def test_completions_token_usage_choices_none():
+    """When response.choices is None (e.g. OpenRouter upstream error), no crash and no output tokens."""
+    span = mock.MagicMock()
+
+    def count_tokens(msg):
+        return len(str(msg))
+
+    response = mock.MagicMock()
+    response.usage = mock.MagicMock()
+    response.usage.completion_tokens = None
+    response.usage.prompt_tokens = None
+    response.usage.total_tokens = None
+    response.choices = None
+    messages = []
+    streaming_message_responses = None
+
+    with mock.patch(
+        "sentry_sdk.integrations.openai.record_token_usage"
+    ) as mock_record_token_usage:
+        _calculate_completions_token_usage(
+            messages=messages,
+            response=response,
+            span=span,
+            streaming_message_responses=streaming_message_responses,
+            streaming_message_total_token_usage=None,
+            count_tokens=count_tokens,
+        )
+        mock_record_token_usage.assert_called_once_with(
+            span,
+            input_tokens=None,
+            input_tokens_cached=None,
+            output_tokens=None,
+            output_tokens_reasoning=None,
+            total_tokens=None,
+        )
+
+
+def test_nonstreaming_chat_completion_choices_none(sentry_init, capture_events):
+    """When choices=None (e.g. OpenRouter upstream error), no crash and span is still created."""
+    sentry_init(integrations=[OpenAIIntegration()], traces_sample_rate=1.0)
+    events = capture_events()
+
+    response = mock.MagicMock()
+    response.id = "chat-id"
+    response.model = "gpt-3.5-turbo"
+    response.choices = None
+    response.usage = mock.MagicMock()
+    response.usage.completion_tokens = None
+    response.usage.prompt_tokens = None
+    response.usage.total_tokens = None
+
+    client = OpenAI(api_key="z")
+    client.chat.completions._post = mock.Mock(return_value=response)
+
+    with start_transaction(name="openai tx"):
+        result = client.chat.completions.create(
+            model="some-model",
+            messages=[{"role": "user", "content": "hello"}],
+        )
+
+    assert result is response
+    (tx,) = events
+    assert tx["type"] == "transaction"
+    assert len(tx["spans"]) == 1
+    span = tx["spans"][0]
+    assert span["op"] == "gen_ai.chat"
+
+
+def test_streaming_chat_completion_choices_none(
+    sentry_init,
+    capture_events,
+    get_model_response,
+    server_side_event_chunks,
+):
+    """When a streaming chunk has choices=None, no crash and token usage is still recorded."""
+    sentry_init(
+        integrations=[OpenAIIntegration(include_prompts=False)],
+        traces_sample_rate=1.0,
+        send_default_pii=False,
+    )
+    events = capture_events()
+
+    # Use model_construct to bypass Pydantic validation and set choices=None
+    chunk_with_none_choices = ChatCompletionChunk.model_construct(
+        id="1",
+        choices=None,
+        created=100000,
+        model="model-id",
+        object="chat.completion.chunk",
+        usage=CompletionUsage(
+            prompt_tokens=5,
+            completion_tokens=0,
+            total_tokens=5,
+        ),
+    )
+    client = OpenAI(api_key="z")
+    returned_stream = get_model_response(
+        server_side_event_chunks(
+            [chunk_with_none_choices],
+            include_event_type=False,
+        )
+    )
+
+    with mock.patch.object(
+        client.chat._client._client,
+        "send",
+        return_value=returned_stream,
+    ):
+        with start_transaction(name="openai tx"):
+            response_stream = client.chat.completions.create(
+                model="some-model",
+                messages=[{"role": "user", "content": "hello"}],
+                stream=True,
+            )
+            for _ in response_stream:
+                pass
+
+    (tx,) = events
+    assert tx["type"] == "transaction"
+    span = tx["spans"][0]
+    assert span["op"] == "gen_ai.chat"
+    assert span["data"][SPANDATA.GEN_AI_RESPONSE_STREAMING] is True
+
+
+@pytest.mark.asyncio
+async def test_streaming_chat_completion_choices_none_async(
+    sentry_init,
+    capture_events,
+    get_model_response,
+    async_iterator,
+    server_side_event_chunks,
+):
+    """When an async streaming chunk has choices=None, no crash and span is still created."""
+    sentry_init(
+        integrations=[OpenAIIntegration(include_prompts=False)],
+        traces_sample_rate=1.0,
+        send_default_pii=False,
+    )
+    events = capture_events()
+
+    chunk_with_none_choices = ChatCompletionChunk.model_construct(
+        id="1",
+        choices=None,
+        created=100000,
+        model="model-id",
+        object="chat.completion.chunk",
+        usage=CompletionUsage(
+            prompt_tokens=5,
+            completion_tokens=0,
+            total_tokens=5,
+        ),
+    )
+    client = AsyncOpenAI(api_key="z")
+    returned_stream = get_model_response(
+        async_iterator(
+            server_side_event_chunks(
+                [chunk_with_none_choices],
+                include_event_type=False,
+            )
+        )
+    )
+
+    with mock.patch.object(
+        client.chat._client._client,
+        "send",
+        return_value=returned_stream,
+    ):
+        with start_transaction(name="openai tx"):
+            response_stream = await client.chat.completions.create(
+                model="some-model",
+                messages=[{"role": "user", "content": "hello"}],
+                stream=True,
+            )
+            async for _ in response_stream:
+                pass
+
+    (tx,) = events
+    assert tx["type"] == "transaction"
+    span = tx["spans"][0]
+    assert span["op"] == "gen_ai.chat"
+    assert span["data"][SPANDATA.GEN_AI_RESPONSE_STREAMING] is True
+
+
 @pytest.mark.skipif(SKIP_RESPONSES_TESTS, reason="Responses API not available")
 def test_responses_token_usage_from_response():
     """Token counts including cached and reasoning tokens are extracted from Responses API."""