Remove comments

Author: jboolean

contrib/mark3labs/mcp-go/hooks_test.go

@@ -42,7 +42,6 @@ func TestAddHooks(t *testing.T) {
 	serverHooks := &server.Hooks{}
 	ddHooks.AddHooks(serverHooks)
 
-	// Verify hooks were added
 	assert.Len(t, serverHooks.OnBeforeCallTool, 1)
 	assert.Len(t, serverHooks.OnAfterCallTool, 1)
 	assert.Len(t, serverHooks.OnError, 1)
@@ -54,31 +53,24 @@ func TestIntegrationSessionInitialize(t *testing.T) {
 	tt := testTracer(t)
 	defer tt.Stop()
 
-	// Create Datadog hooks
 	ddHooks := NewHooks()
 	defer ddHooks.Stop()
 
-	// Create server hooks and add Datadog tracing
 	hooks := &server.Hooks{}
 	ddHooks.AddHooks(hooks)
 
-	// Create MCP server with hooks
 	srv := server.NewMCPServer("test-server", "1.0.0",
 		server.WithHooks(hooks))
 
-	// Create initialize request
 	ctx := context.Background()
 	initRequest := `{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test-client","version":"1.0.0"}}}`
 
-	// Send initialize request
 	response := srv.HandleMessage(ctx, []byte(initRequest))
 	assert.NotNil(t, response)
 
-	// Marshal response to check it
 	responseBytes, err := json.Marshal(response)
 	require.NoError(t, err)
 
-	// Verify response is valid JSON-RPC
 	var resp map[string]interface{}
 	err = json.Unmarshal(responseBytes, &resp)
 	require.NoError(t, err)
@@ -91,19 +83,15 @@ func TestIntegrationToolCallSuccess(t *testing.T) {
 	tt := testTracer(t)
 	defer tt.Stop()
 
-	// Create Datadog hooks
 	ddHooks := NewHooks()
 	defer ddHooks.Stop()
 
-	// Create server hooks and add Datadog tracing
 	hooks := &server.Hooks{}
 	ddHooks.AddHooks(hooks)
 
-	// Create MCP server with hooks
 	srv := server.NewMCPServer("test-server", "1.0.0",
 		server.WithHooks(hooks))
 
-	// Add a simple calculator tool
 	calcTool := mcp.NewTool("calculator",
 		mcp.WithDescription("A simple calculator"))
 
@@ -126,132 +114,108 @@ func TestIntegrationToolCallSuccess(t *testing.T) {
 		return mcp.NewToolResultText(string(resultJSON)), nil
 	})
 
-	// Initialize session using default session manager
 	ctx := context.Background()
 	sessionID := "test-session-123"
 
-	// Create a mock session and add it to context
 	session := &mockSession{id: sessionID}
 	session.Initialize()
 	ctx = srv.WithContext(ctx, session)
 
-	// Create the actual MCP tools/call request as JSON
 	toolCallRequest := `{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"calculator","arguments":{"operation":"add","x":5,"y":3}}}`
 
-	// Call the actual MCP server's HandleMessage method
 	response := srv.HandleMessage(ctx, []byte(toolCallRequest))
 	assert.NotNil(t, response)
 
-	// Marshal response to check it
 	responseBytes, err := json.Marshal(response)
 	require.NoError(t, err)
 
-	// Verify response contains result
 	var resp map[string]interface{}
 	err = json.Unmarshal(responseBytes, &resp)
 	require.NoError(t, err)
 	assert.Equal(t, "2.0", resp["jsonrpc"])
 	assert.NotNil(t, resp["result"])
 
-	// Verify LLMObs tool span was created
 	spans := tt.WaitForLLMObsSpans(t, 1)
 	require.Len(t, spans, 1)
 
 	toolSpan := spans[0]
 	assert.Equal(t, "calculator", toolSpan.Name)
 	assert.Equal(t, "tool", toolSpan.Meta["span.kind"])
 
-	// Verify input/output annotations exist
 	assert.Contains(t, toolSpan.Meta, "input")
 	assert.Contains(t, toolSpan.Meta, "output")
 
-	// The Meta field contains map[string]any, so we need to handle it as such
 	inputMeta := toolSpan.Meta["input"]
 	assert.NotNil(t, inputMeta)
 
-	// Input could be a map or string, marshal to JSON to check content
 	inputJSON, err := json.Marshal(inputMeta)
 	require.NoError(t, err)
 	inputStr := string(inputJSON)
 	assert.Contains(t, inputStr, "calculator")
 	assert.Contains(t, inputStr, "add")
 
-	// Same for output
 	outputMeta := toolSpan.Meta["output"]
 	assert.NotNil(t, outputMeta)
 
 	outputJSON, err := json.Marshal(outputMeta)
 	require.NoError(t, err)
 	outputStr := string(outputJSON)
-	assert.Contains(t, outputStr, "8") // result of 5 + 3
+	assert.Contains(t, outputStr, "8")
 }
 
 func TestIntegrationToolCallError(t *testing.T) {
 	tt := testTracer(t)
 	defer tt.Stop()
 
-	// Create Datadog hooks
 	ddHooks := NewHooks()
 	defer ddHooks.Stop()
 
-	// Create server hooks and add Datadog tracing
 	hooks := &server.Hooks{}
 	ddHooks.AddHooks(hooks)
 
-	// Create MCP server with hooks
 	srv := server.NewMCPServer("test-server", "1.0.0",
 		server.WithHooks(hooks))
 
-	// Add a tool that always errors
 	errorTool := mcp.NewTool("error_tool",
 		mcp.WithDescription("A tool that always errors"))
 
 	srv.AddTool(errorTool, func(ctx context.Context, request mcp.CallToolRequest) (*mcp.CallToolResult, error) {
 		return nil, errors.New("intentional test error")
 	})
 
-	// Initialize session
 	ctx := context.Background()
 	sessionID := "test-session-456"
 
-	// Create a mock session and add it to context
 	session := &mockSession{id: sessionID}
 	session.Initialize()
 	ctx = srv.WithContext(ctx, session)
 
-	// Create the actual MCP tools/call request as JSON
 	toolCallRequest := `{"jsonrpc":"2.0","id":3,"method":"tools/call","params":{"name":"error_tool","arguments":{}}}`
 
-	// Call the actual MCP server's HandleMessage method
 	response := srv.HandleMessage(ctx, []byte(toolCallRequest))
 	assert.NotNil(t, response)
 
-	// Marshal response to check it
 	responseBytes, err := json.Marshal(response)
 	require.NoError(t, err)
 
-	// Verify response contains error
 	var resp map[string]interface{}
 	err = json.Unmarshal(responseBytes, &resp)
 	require.NoError(t, err)
 	assert.Equal(t, "2.0", resp["jsonrpc"])
 	assert.NotNil(t, resp["error"])
 
-	// Verify LLMObs tool span was created with error
 	spans := tt.WaitForLLMObsSpans(t, 1)
 	require.Len(t, spans, 1)
 
 	toolSpan := spans[0]
 	assert.Equal(t, "error_tool", toolSpan.Name)
 	assert.Equal(t, "tool", toolSpan.Meta["span.kind"])
 
-	// Verify error was recorded
 	assert.Contains(t, toolSpan.Meta, "error.message")
 	assert.Contains(t, toolSpan.Meta["error.message"], "intentional test error")
 	assert.Contains(t, toolSpan.Meta, "error.type")
 	assert.Contains(t, toolSpan.Meta, "error.stack")
 
-	// Verify input annotation was still added
 	assert.Contains(t, toolSpan.Meta, "input")
 }