test(langchain): Consolidate available tools assertion

tests/integrations/langchain/test_langchain.py

@@ -305,12 +305,8 @@ def test_langchain_agent(
 
     # Verify that available tools are always recorded regardless of PII settings
     for chat_span in chat_spans:
-        span_data = chat_span.get("data", {})
-        if SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS in span_data:
-            tools_data = span_data[SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS]
-            assert tools_data is not None, (
-                "Available tools should always be recorded regardless of PII settings"
-            )
+        tools_data = chat_span["data"][SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS]
+        assert "get_word_length" in tools_data
 
 
 def test_langchain_error(sentry_init, capture_events):
@@ -718,79 +714,6 @@ def test_langchain_callback_list_existing_callback(sentry_init):
         assert handler is sentry_callback
 
 
-def test_tools_integration_in_spans(sentry_init, capture_events):
-    """Test that tools are properly set on spans in actual LangChain integration."""
-    global llm_type
-    llm_type = "openai-chat"
-
-    sentry_init(
-        integrations=[LangchainIntegration(include_prompts=False)],
-        traces_sample_rate=1.0,
-    )
-    events = capture_events()
-
-    prompt = ChatPromptTemplate.from_messages(
-        [
-            ("system", "You are a helpful assistant"),
-            ("user", "{input}"),
-            MessagesPlaceholder(variable_name="agent_scratchpad"),
-        ]
-    )
-
-    global stream_result_mock
-    stream_result_mock = Mock(
-        side_effect=[
-            [
-                ChatGenerationChunk(
-                    type="ChatGenerationChunk",
-                    message=AIMessageChunk(content="Simple response"),
-                ),
-            ]
-        ]
-    )
-
-    llm = MockOpenAI(
-        model_name="gpt-3.5-turbo",
-        temperature=0,
-        openai_api_key="badkey",
-    )
-    agent = create_openai_tools_agent(llm, [get_word_length], prompt)
-    agent_executor = AgentExecutor(agent=agent, tools=[get_word_length], verbose=True)
-
-    with start_transaction():
-        list(agent_executor.stream({"input": "Hello"}))
-
-    # Check that events were captured and contain tools data
-    if events:
-        tx = events[0]
-        spans = tx.get("spans", [])
-
-        # Look for spans that should have tools data
-        tools_found = False
-        for span in spans:
-            span_data = span.get("data", {})
-            if SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS in span_data:
-                tools_found = True
-                tools_data = span_data[SPANDATA.GEN_AI_REQUEST_AVAILABLE_TOOLS]
-                # Verify tools are in the expected format
-                assert isinstance(tools_data, (str, list))  # Could be serialized
-                if isinstance(tools_data, str):
-                    # If serialized as string, should contain tool name
-                    assert "get_word_length" in tools_data
-                else:
-                    # If still a list, verify structure
-                    assert len(tools_data) >= 1
-                    names = [
-                        tool.get("name")
-                        for tool in tools_data
-                        if isinstance(tool, dict)
-                    ]
-                    assert "get_word_length" in names
-
-        # Ensure we found at least one span with tools data
-        assert tools_found, "No spans found with tools data"
-
-
 def test_langchain_integration_with_langchain_core_only(sentry_init, capture_events):
     """Test that the langchain integration works when langchain.agents.AgentExecutor
     is not available or langchain is not installed, but langchain-core is.