EPMRPP-108935 || MCP Server. Tools. Add a user's RP project name to the HTTP header

Author: AleksandrParamonoff

Taskfile.yaml

@@ -29,6 +29,11 @@ tasks:
     desc: "Runs GolangCI linter"
     cmd: "{{.GOLANG_CI}} run ./..."
 
+  checks:
+    desc: "Runs checks (formatter and linter)"
+    cmd: |
+      go mod tidy && {{.GOLANG_CI}} fmt ./... && {{.GOLANG_CI}} run ./...
+
   test:
     desc: "Runs tests"
     cmd: "go test ./..."

internal/reportportal/http_token_middleware.go

@@ -11,9 +11,11 @@ import (
 const (
 	// RPTokenContextKey is used to store RP API token in request context
 	RPTokenContextKey contextKey = "rp_api_token" //nolint:gosec // This is a context key, not a credential
+	// RPProjectContextKey is used to store RP project parameter in request context
+	RPProjectContextKey contextKey = "rp_project" //nolint:gosec // This is a context key, not a credential
 )
 
-// HTTPTokenMiddleware returns an HTTP middleware function that extracts RP API tokens
+// HTTPTokenMiddleware returns an HTTP middleware function that extracts RP API tokens and project parameters
 func HTTPTokenMiddleware(next http.Handler) http.Handler {
 	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// Extract RP API token from request headers
@@ -34,6 +36,25 @@ func HTTPTokenMiddleware(next http.Handler) http.Handler {
 				"checked_headers", []string{"Authorization"})
 		}
 
+		// Extract project parameter from request headers
+		rpProject := extractRPProjectFromRequest(r)
+
+		if rpProject != "" {
+			// Add project to request context for use by MCP handlers
+			r = r.WithContext(WithProjectInContext(r.Context(), rpProject))
+
+			slog.Debug("Extracted RP project parameter from HTTP request",
+				"source", "http_header",
+				"method", r.Method,
+				"path", r.URL.Path,
+				"project", rpProject)
+		} else {
+			slog.Debug("No RP project parameter found in HTTP request headers",
+				"method", r.Method,
+				"path", r.URL.Path,
+				"checked_headers", []string{"X-Project"})
+		}
+
 		// Continue to next handler
 		next.ServeHTTP(w, r)
 	})
@@ -74,3 +95,30 @@ func GetTokenFromContext(ctx context.Context) (string, bool) {
 	token, ok := ctx.Value(RPTokenContextKey).(string)
 	return token, ok && token != ""
 }
+
+// extractRPProjectFromRequest extracts RP project parameter from HTTP request headers
+// Supports X-Project header
+func extractRPProjectFromRequest(r *http.Request) string {
+	project := strings.TrimSpace(r.Header.Get("X-Project"))
+	if project != "" {
+		slog.Debug("Valid RP project parameter extracted from request header",
+			"source", "X-Project",
+			"project", project)
+		return project
+	}
+	return ""
+}
+
+// WithProjectInContext adds RP project parameter to request context
+func WithProjectInContext(ctx context.Context, project string) context.Context {
+	// Trim whitespace from project parameter
+	project = strings.TrimSpace(project)
+	return context.WithValue(ctx, RPProjectContextKey, project)
+}
+
+// GetProjectFromContext extracts RP project parameter from request context
+func GetProjectFromContext(ctx context.Context) (string, bool) {
+	project, ok := ctx.Value(RPProjectContextKey).(string)
+	res := strings.TrimSpace(project)
+	return res, ok && res != ""
+}

internal/reportportal/http_token_middleware_test.go

@@ -0,0 +1,272 @@
+package mcpreportportal
+
+import (
+	"context"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestExtractRPProjectFromRequest(t *testing.T) {
+	tests := []struct {
+		name           string
+		headers        map[string]string
+		expectedResult string
+	}{
+		{
+			name:           "valid X-Project header",
+			headers:        map[string]string{"X-Project": "test-project"},
+			expectedResult: "test-project",
+		},
+		{
+			name:           "X-Project header with whitespace",
+			headers:        map[string]string{"X-Project": "  test-project  "},
+			expectedResult: "test-project",
+		},
+		{
+			name:           "empty X-Project header",
+			headers:        map[string]string{"X-Project": ""},
+			expectedResult: "",
+		},
+		{
+			name:           "missing X-Project header",
+			headers:        map[string]string{},
+			expectedResult: "",
+		},
+		{
+			name:           "X-Project header with only whitespace",
+			headers:        map[string]string{"X-Project": "   "},
+			expectedResult: "",
+		},
+		{
+			name:           "case insensitive header name",
+			headers:        map[string]string{"x-project": "test-project"},
+			expectedResult: "test-project",
+		},
+		{
+			name: "other headers present but no X-Project",
+			headers: map[string]string{
+				"Authorization": "Bearer token",
+				"Content-Type":  "application/json",
+			},
+			expectedResult: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			req := httptest.NewRequest("GET", "/test", nil)
+
+			// Set headers
+			for key, value := range tt.headers {
+				req.Header.Set(key, value)
+			}
+
+			result := extractRPProjectFromRequest(req)
+			assert.Equal(t, tt.expectedResult, result)
+		})
+	}
+}
+
+func TestWithProjectInContext(t *testing.T) {
+	ctx := context.Background()
+	project := "test-project"
+
+	// Test adding project to context
+	ctxWithProject := WithProjectInContext(ctx, project)
+
+	// Test retrieving project from context
+	retrievedProject, ok := GetProjectFromContext(ctxWithProject)
+	assert.True(t, ok)
+	assert.Equal(t, project, retrievedProject)
+
+	// Test that original context doesn't have project
+	_, ok = GetProjectFromContext(ctx)
+	assert.False(t, ok)
+}
+
+func TestGetProjectFromContext(t *testing.T) {
+	tests := []struct {
+		name            string
+		contextValue    interface{}
+		expectedProject string
+		expectedOk      bool
+	}{
+		{
+			name:            "valid project string",
+			contextValue:    "test-project",
+			expectedProject: "test-project",
+			expectedOk:      true,
+		},
+		{
+			name:            "empty project string",
+			contextValue:    "",
+			expectedProject: "",
+			expectedOk:      false,
+		},
+		{
+			name:            "nil context value",
+			contextValue:    nil,
+			expectedProject: "",
+			expectedOk:      false,
+		},
+		{
+			name:            "non-string context value",
+			contextValue:    123,
+			expectedProject: "",
+			expectedOk:      false,
+		},
+		{
+			name:            "context without project key",
+			contextValue:    nil, // This will be handled by the context not having the key
+			expectedProject: "",
+			expectedOk:      false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			ctx := context.Background()
+
+			if tt.contextValue != nil {
+				ctx = context.WithValue(ctx, RPProjectContextKey, tt.contextValue)
+			}
+
+			project, ok := GetProjectFromContext(ctx)
+			assert.Equal(t, tt.expectedOk, ok)
+			assert.Equal(t, tt.expectedProject, project)
+		})
+	}
+}
+
+func TestHTTPTokenMiddleware_ProjectExtraction(t *testing.T) {
+	tests := []struct {
+		name            string
+		headers         map[string]string
+		expectProject   bool
+		expectedProject string
+	}{
+		{
+			name:            "X-Project header present",
+			headers:         map[string]string{"X-Project": "test-project"},
+			expectProject:   true,
+			expectedProject: "test-project",
+		},
+		{
+			name:            "X-Project header missing",
+			headers:         map[string]string{},
+			expectProject:   false,
+			expectedProject: "",
+		},
+		{
+			name:            "X-Project header empty",
+			headers:         map[string]string{"X-Project": ""},
+			expectProject:   false,
+			expectedProject: "",
+		},
+		{
+			name:            "X-Project header with whitespace",
+			headers:         map[string]string{"X-Project": "  test-project  "},
+			expectProject:   true,
+			expectedProject: "test-project",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			// Create a test handler that checks the context
+			var capturedProject string
+			var projectFound bool
+
+			testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				project, ok := GetProjectFromContext(r.Context())
+				capturedProject = project
+				projectFound = ok
+				w.WriteHeader(http.StatusOK)
+			})
+
+			// Create middleware
+			middleware := HTTPTokenMiddleware(testHandler)
+
+			// Create request with headers
+			req := httptest.NewRequest("GET", "/test", nil)
+			for key, value := range tt.headers {
+				req.Header.Set(key, value)
+			}
+
+			// Create response recorder
+			rr := httptest.NewRecorder()
+
+			// Execute middleware
+			middleware.ServeHTTP(rr, req)
+
+			// Verify response
+			assert.Equal(t, http.StatusOK, rr.Code)
+
+			// Verify project extraction
+			assert.Equal(t, tt.expectProject, projectFound)
+			if tt.expectProject {
+				assert.Equal(t, tt.expectedProject, capturedProject)
+			}
+		})
+	}
+}
+
+func TestHTTPTokenMiddleware_CombinedTokenAndProject(t *testing.T) {
+	// Test that both token and project can be extracted simultaneously
+	req := httptest.NewRequest("GET", "/test", nil)
+	req.Header.Set("Authorization", "Bearer 1234567890123456")
+	req.Header.Set("X-Project", "test-project")
+
+	var capturedToken, capturedProject string
+	var tokenFound, projectFound bool
+
+	testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		token, ok := GetTokenFromContext(r.Context())
+		capturedToken = token
+		tokenFound = ok
+
+		project, ok := GetProjectFromContext(r.Context())
+		capturedProject = project
+		projectFound = ok
+
+		w.WriteHeader(http.StatusOK)
+	})
+
+	middleware := HTTPTokenMiddleware(testHandler)
+	rr := httptest.NewRecorder()
+
+	middleware.ServeHTTP(rr, req)
+
+	// Verify both token and project were extracted
+	assert.Equal(t, http.StatusOK, rr.Code)
+	assert.True(t, tokenFound)
+	assert.Equal(t, "1234567890123456", capturedToken)
+	assert.True(t, projectFound)
+	assert.Equal(t, "test-project", capturedProject)
+}
+
+func TestHTTPTokenMiddleware_NoHeaders(t *testing.T) {
+	// Test middleware with no headers
+	req := httptest.NewRequest("GET", "/test", nil)
+
+	var tokenFound, projectFound bool
+
+	testHandler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		_, tokenFound = GetTokenFromContext(r.Context())
+		_, projectFound = GetProjectFromContext(r.Context())
+		w.WriteHeader(http.StatusOK)
+	})
+
+	middleware := HTTPTokenMiddleware(testHandler)
+	rr := httptest.NewRecorder()
+
+	middleware.ServeHTTP(rr, req)
+
+	// Verify no token or project were found
+	assert.Equal(t, http.StatusOK, rr.Code)
+	assert.False(t, tokenFound)
+	assert.False(t, projectFound)
+}