HTTP Layer for Update Saved Search

backend/pkg/httpserver/create_saved_search.go

@@ -61,28 +61,71 @@ func (f fieldValidationErrors) hasErrors() bool {
 	return len(f.fieldErrorMap) > 0
 }
 
-func validateSavedSearch(input *backend.SavedSearch) *fieldValidationErrors {
-	fieldErrors := &fieldValidationErrors{fieldErrorMap: nil}
+// validateSavedSearchName checks the validity of the saved search name.
+// It expects a pointer to handle potential nil values during updates.
+func validateSavedSearchName(name *string, fieldErrors *fieldValidationErrors) {
+	if name == nil {
+		// Treat nil as invalid if validation is requested
+		fieldErrors.addFieldError("name", errSavedSearchInvalidNameLength)
 
-	if len(input.Name) < savedSearchNameMinLength || len(input.Name) > savedSearchNameMaxLength {
+		return
+	}
+	if len(*name) < savedSearchNameMinLength || len(*name) > savedSearchNameMaxLength {
 		fieldErrors.addFieldError("name", errSavedSearchInvalidNameLength)
 	}
+}
 
-	if len(input.Query) < savedSearchQueryMinLength || len(input.Query) > savedSearchQueryMaxLength {
+// validateSavedSearchQuery checks the validity of the saved search query.
+// It expects a pointer to handle potential nil values during updates.
+func validateSavedSearchQuery(query *string, fieldErrors *fieldValidationErrors) {
+	if query == nil {
 		fieldErrors.addFieldError("query", errSavedSearchInvalidQueryLength)
-	} else {
-		parser := searchtypes.FeaturesSearchQueryParser{}
-		_, err := parser.Parse(input.Query)
-		if err != nil {
-			fieldErrors.addFieldError("query", errQueryDoesNotMatchGrammar)
-		}
 
+		return
+	}
+
+	if len(*query) < savedSearchQueryMinLength || len(*query) > savedSearchQueryMaxLength {
+		fieldErrors.addFieldError("query", errSavedSearchInvalidQueryLength)
+
+		return
+	}
+
+	// Only parse if length is okay
+	parser := searchtypes.FeaturesSearchQueryParser{}
+	_, err := parser.Parse(*query)
+	if err != nil {
+		fieldErrors.addFieldError("query", errQueryDoesNotMatchGrammar)
 	}
 
-	if input.Description != nil && (len(*input.Description) < savedSearchNameDescriptionMinLength ||
-		len(*input.Description) > savedSearchNameDescriptionMaxLength) {
+}
+
+// validateSavedSearchDescription checks the validity of the saved search description.
+// Description is optional, so nil is allowed. Validation only occurs if non-nil.
+func validateSavedSearchDescription(description *string, fieldErrors *fieldValidationErrors) {
+	// If description is nil, it's considered valid (optional field).
+	if description == nil {
+		return
+	}
+
+	// If description is provided (non-nil), validate its length.
+	if len(*description) < savedSearchNameDescriptionMinLength ||
+		len(*description) > savedSearchNameDescriptionMaxLength {
 		fieldErrors.addFieldError("description", errSavedSearchInvalidDescriptionLength)
 	}
+}
+
+func validateSavedSearch(input *backend.SavedSearch) *fieldValidationErrors {
+	fieldErrors := &fieldValidationErrors{fieldErrorMap: nil}
+
+	// Validate Name (using address of the string field)
+	validateSavedSearchName(&input.Name, fieldErrors)
+
+	// Validate Query (using address of the string field)
+	validateSavedSearchQuery(&input.Query, fieldErrors)
+
+	// Validate Description (already a pointer)
+	validateSavedSearchDescription(input.Description, fieldErrors)
+
 	if fieldErrors.hasErrors() {
 		return fieldErrors
 	}

backend/pkg/httpserver/create_saved_search_test.go

@@ -193,6 +193,26 @@ func TestCreateSavedSearch(t *testing.T) {
 					"message":"input validation errors"
 				}`),
 		},
+		{
+			name:                            "missing body creation error",
+			mockCreateUserSavedSearchConfig: nil,
+			authMiddlewareOption:            withAuthMiddleware(mockAuthMiddleware(testUser)),
+			request: httptest.NewRequest(
+				http.MethodPost,
+				"/v1/saved-searches",
+				strings.NewReader(`{}`),
+			),
+			expectedResponse: testJSONResponse(400,
+				`{
+					"code":400,
+					"errors":{
+						"name":"name must be between 1 and 32 characters long",
+						"query":"query must be between 1 and 256 characters long"
+					},
+					"message":"input validation errors"
+				}`,
+			),
+		},
 		{
 			name: "general creation error",
 			mockCreateUserSavedSearchConfig: &MockCreateUserSavedSearchConfig{

backend/pkg/httpserver/server.go

@@ -123,6 +123,12 @@ type WPTMetricsStorer interface {
 		pageSize int,
 		pageToken *string,
 	) (*backend.UserSavedSearchPage, error)
+	UpdateUserSavedSearch(
+		ctx context.Context,
+		savedSearchID string,
+		userID string,
+		savedSearch *backend.SavedSearchUpdateRequest,
+	) (*backend.SavedSearchResponse, error)
 }
 
 type Server struct {
@@ -131,18 +137,6 @@ type Server struct {
 	operationResponseCaches *operationResponseCaches
 }
 
-// UpdateSavedSearch implements backend.StrictServerInterface.
-// nolint: revive, ireturn // Name generated from openapi
-func (s *Server) UpdateSavedSearch(
-	ctx context.Context, request backend.UpdateSavedSearchRequestObject) (
-	backend.UpdateSavedSearchResponseObject, error) {
-	return backend.UpdateSavedSearch400JSONResponse{
-		Code:    http.StatusBadRequest,
-		Message: "TODO",
-		Errors:  nil,
-	}, nil
-}
-
 // GetUserSavedSearchBookmark implements backend.StrictServerInterface.
 // nolint: revive, ireturn // Name generated from openapi
 func (s *Server) GetUserSavedSearchBookmark(

backend/pkg/httpserver/server_test.go

@@ -193,6 +193,14 @@ type MockListUserSavedSeachesConfig struct {
 	err               error
 }
 
+type MockUpdateUserSavedSearchConfig struct {
+	expectedSavedSearchID string
+	expectedUserID        string
+	expectedUpdateRequest *backend.SavedSearchUpdateRequest
+	output                *backend.SavedSearchResponse
+	err                   error
+}
+
 type MockWPTMetricsStorer struct {
 	featureCfg                                        *MockListMetricsForFeatureIDBrowserAndChannelConfig
 	aggregateCfg                                      *MockListMetricsOverTimeWithAggregatedTotalsConfig
@@ -208,6 +216,7 @@ type MockWPTMetricsStorer struct {
 	deleteUserSavedSearchCfg                          *MockDeleteUserSavedSearchConfig
 	getSavedSearchCfg                                 *MockGetSavedSearchConfig
 	listUserSavedSearchesCfg                          *MockListUserSavedSeachesConfig
+	updateUserSavedSearchCfg                          *MockUpdateUserSavedSearchConfig
 	t                                                 *testing.T
 	callCountListMissingOneImplCounts                 int
 	callCountListMissingOneImplFeatures               int
@@ -222,6 +231,7 @@ type MockWPTMetricsStorer struct {
 	callCountDeleteUserSavedSearch                    int
 	callCountGetSavedSearch                           int
 	callCountListUserSavedSearches                    int
+	callCountUpdateUserSavedSearch                    int
 }
 
 func (m *MockWPTMetricsStorer) GetIDFromFeatureKey(
@@ -494,6 +504,29 @@ func (m *MockWPTMetricsStorer) DeleteUserSavedSearch(
 	return m.deleteUserSavedSearchCfg.err
 }
 
+func (m *MockWPTMetricsStorer) UpdateUserSavedSearch(
+	_ context.Context,
+	savedSearchID string,
+	userID string,
+	req *backend.SavedSearchUpdateRequest,
+) (*backend.SavedSearchResponse, error) {
+	m.callCountUpdateUserSavedSearch++
+
+	if savedSearchID != m.updateUserSavedSearchCfg.expectedSavedSearchID ||
+		userID != m.updateUserSavedSearchCfg.expectedUserID ||
+		!reflect.DeepEqual(req, m.updateUserSavedSearchCfg.expectedUpdateRequest) {
+		m.t.Errorf("Incorrect arguments. Expected: ( %s %s %v ), Got: { %s %s %v}",
+			m.updateUserSavedSearchCfg.expectedSavedSearchID,
+			m.updateUserSavedSearchCfg.expectedUserID,
+			m.updateUserSavedSearchCfg.expectedUpdateRequest,
+			savedSearchID,
+			userID,
+			req)
+	}
+
+	return m.updateUserSavedSearchCfg.output, m.updateUserSavedSearchCfg.err
+}
+
 func (m *MockWPTMetricsStorer) ListUserSavedSearches(
 	_ context.Context,
 	userID string,

backend/pkg/httpserver/update_saved_search.go

@@ -0,0 +1,132 @@
+// Copyright 2025 Google LLC
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package httpserver
+
+import (
+	"context"
+	"errors"
+	"log/slog"
+	"net/http"
+	"strings"
+
+	"github.com/GoogleChrome/webstatus.dev/lib/gcpspanner/spanneradapters/backendtypes"
+	"github.com/GoogleChrome/webstatus.dev/lib/gen/openapi/backend"
+	"github.com/GoogleChrome/webstatus.dev/lib/httpmiddlewares"
+)
+
+// validateSavedSearchUpdate handles validation when updating an existing SavedSearch.
+func validateSavedSearchUpdate(input *backend.UpdateSavedSearchJSONRequestBody) *fieldValidationErrors {
+	activeMasks := make(map[backend.SavedSearchUpdateRequestUpdateMask]bool)
+	var invalidMasks []string
+
+	fieldErrors := &fieldValidationErrors{fieldErrorMap: nil}
+
+	if len(input.UpdateMask) == 0 {
+		fieldErrors.addFieldError("update_mask", errors.New("update_mask must be set"))
+
+		return fieldErrors
+	}
+
+	for _, mask := range input.UpdateMask {
+		switch mask {
+		case
+			backend.SavedSearchUpdateRequestMaskName,
+			backend.SavedSearchUpdateRequestMaskQuery,
+			backend.SavedSearchUpdateRequestMaskDescription:
+			activeMasks[mask] = true
+		default:
+			invalidMasks = append(invalidMasks, string(mask))
+		}
+	}
+
+	if len(invalidMasks) > 0 {
+		fieldErrors.addFieldError("update_mask", errors.New("invalid update_mask values: "+
+			strings.Join(invalidMasks, ", "),
+		))
+
+		return fieldErrors
+	}
+
+	// Validate Name only if it's in the update mask
+	if activeMasks[backend.SavedSearchUpdateRequestMaskName] {
+		validateSavedSearchName(input.Name, fieldErrors)
+	}
+
+	// Validate Query only if it's in the update mask
+	if activeMasks[backend.SavedSearchUpdateRequestMaskQuery] {
+		// Original logic also checked for nil before length/parsing.
+		validateSavedSearchQuery(input.Query, fieldErrors)
+	}
+
+	// Validate Description only if it's in the update mask
+	if activeMasks[backend.SavedSearchUpdateRequestMaskDescription] {
+		validateSavedSearchDescription(input.Description, fieldErrors)
+	}
+
+	if fieldErrors.hasErrors() {
+		return fieldErrors
+	}
+
+	return nil
+}
+
+// UpdateSavedSearch implements backend.StrictServerInterface.
+// nolint: ireturn // Name generated from openapi
+func (s *Server) UpdateSavedSearch(
+	ctx context.Context, request backend.UpdateSavedSearchRequestObject) (
+	backend.UpdateSavedSearchResponseObject, error) {
+	// At this point, the user should be authenticated and in the context.
+	// If for some reason the user is not in the context, it is a library or
+	// internal issue and not an user issue. Return 500 error in that case.
+	user, found := httpmiddlewares.AuthenticatedUserFromContext(ctx)
+	if !found {
+		slog.ErrorContext(ctx, "user not found in context. middleware malfunction")
+
+		return backend.UpdateSavedSearch500JSONResponse{
+			Code:    http.StatusInternalServerError,
+			Message: "internal server error",
+		}, nil
+	}
+	validationErr := validateSavedSearchUpdate(request.Body)
+	if validationErr != nil {
+		return backend.UpdateSavedSearch400JSONResponse{
+			Code:    http.StatusBadRequest,
+			Message: "input validation errors",
+			Errors:  validationErr.fieldErrorMap,
+		}, nil
+	}
+	output, err := s.wptMetricsStorer.UpdateUserSavedSearch(ctx, request.SearchId, user.ID, request.Body)
+	if err != nil {
+		if errors.Is(err, backendtypes.ErrUserNotAuthorizedForAction) {
+			return backend.UpdateSavedSearch403JSONResponse{
+				Code:    http.StatusForbidden,
+				Message: "forbidden",
+			}, nil
+		} else if errors.Is(err, backendtypes.ErrEntityDoesNotExist) {
+			return backend.UpdateSavedSearch404JSONResponse{
+				Code:    http.StatusNotFound,
+				Message: "saved search not found",
+			}, nil
+		}
+		slog.ErrorContext(ctx, "unable to update user saved search", "error", err)
+
+		return backend.UpdateSavedSearch500JSONResponse{
+			Code:    http.StatusInternalServerError,
+			Message: "unable to update user saved search",
+		}, nil
+	}
+
+	return backend.UpdateSavedSearch200JSONResponse(*output), nil
+}