Add adapter logic to handle bookmark operations

This change adds the adapter logic for the putUserSavedSearchBookmark
and removeUserSavedSearchBookmark operations.

putUserSavedSearchBookmark handles converting the errors from spanner
for 1) bookmark limit exceeded and 2) entity does not exist to errors
that the http layer will use to return the appropriate status code

removeUserSavedSearchBookmark handles converting the errors from spanner
for 1) saved search owner cannot delete bookmark and 2) entity does not exist to errors
that the http layer will use to return the appropriate status code

Author: jcscottiii

lib/gcpspanner/spanneradapters/backend.go

@@ -125,6 +125,8 @@ type BackendSpannerClient interface {
 		pageSize int,
 		pageToken *string) (*gcpspanner.UserSavedSearchesPage, error)
 	UpdateUserSavedSearch(ctx context.Context, req gcpspanner.UpdateSavedSearchRequest) error
+	AddUserSearchBookmark(ctx context.Context, req gcpspanner.UserSavedSearchBookmark) error
+	DeleteUserSearchBookmark(ctx context.Context, req gcpspanner.UserSavedSearchBookmark) error
 }
 
 // Backend converts queries to spanner to usable entities for the backend
@@ -617,6 +619,50 @@ func (s *Backend) UpdateUserSavedSearch(
 	return convertUserSavedSearchToSavedSearchResponse(savedSearch), nil
 }
 
+func (s *Backend) PutUserSavedSearchBookmark(
+	ctx context.Context,
+	userID string,
+	savedSearchID string,
+) error {
+	err := s.client.AddUserSearchBookmark(ctx, gcpspanner.UserSavedSearchBookmark{
+		UserID:        userID,
+		SavedSearchID: savedSearchID,
+	})
+	if err != nil {
+		if errors.Is(err, gcpspanner.ErrUserSearchBookmarkLimitExceeded) {
+			return errors.Join(err, backendtypes.ErrUserMaxBookmarks)
+		} else if errors.Is(err, gcpspanner.ErrQueryReturnedNoResults) {
+			return errors.Join(err, backendtypes.ErrEntityDoesNotExist)
+		}
+
+		return err
+	}
+
+	return nil
+}
+
+func (s *Backend) RemoveUserSavedSearchBookmark(
+	ctx context.Context,
+	userID string,
+	savedSearchID string,
+) error {
+	err := s.client.DeleteUserSearchBookmark(ctx, gcpspanner.UserSavedSearchBookmark{
+		UserID:        userID,
+		SavedSearchID: savedSearchID,
+	})
+	if err != nil {
+		if errors.Is(err, gcpspanner.ErrOwnerCannotDeleteBookmark) {
+			return errors.Join(err, backendtypes.ErrUserNotAuthorizedForAction)
+		} else if errors.Is(err, gcpspanner.ErrQueryReturnedNoResults) {
+			return errors.Join(err, backendtypes.ErrEntityDoesNotExist)
+		}
+
+		return err
+	}
+
+	return nil
+}
+
 func convertUserSavedSearchToSavedSearchResponse(savedSearch *gcpspanner.UserSavedSearch) *backend.SavedSearchResponse {
 	return &backend.SavedSearchResponse{
 		Id:             savedSearch.ID,

lib/gcpspanner/spanneradapters/backend_test.go

@@ -115,6 +115,16 @@ type mockUpdateUserSavedSearchConfig struct {
 	returnedError   error
 }
 
+type mockAddUserSearchBookmarkConfig struct {
+	expectedRequest gcpspanner.UserSavedSearchBookmark
+	returnedError   error
+}
+
+type mockDeleteUserSearchBookmarkConfig struct {
+	expectedRequest gcpspanner.UserSavedSearchBookmark
+	returnedError   error
+}
+
 type mockBackendSpannerClient struct {
 	t                                    *testing.T
 	aggregationData                      []gcpspanner.WPTRunAggregationMetricWithTime
@@ -132,10 +142,32 @@ type mockBackendSpannerClient struct {
 	mockDeleteUserSavedSearchCfg         *mockDeleteUserSavedSearchConfig
 	mockListUserSavedSearchesCfg         *mockListUserSavedSearchesConfig
 	mockUpdateUserSavedSearchCfg         *mockUpdateUserSavedSearchConfig
+	mockAddUserSearchBookmarkCfg         *mockAddUserSearchBookmarkConfig
+	mockDeleteUserSearchBookmarkCfg      *mockDeleteUserSearchBookmarkConfig
 	pageToken                            *string
 	err                                  error
 }
 
+// AddUserSearchBookmark implements BackendSpannerClient.
+func (c mockBackendSpannerClient) AddUserSearchBookmark(
+	_ context.Context, req gcpspanner.UserSavedSearchBookmark) error {
+	if !reflect.DeepEqual(req, c.mockAddUserSearchBookmarkCfg.expectedRequest) {
+		c.t.Error("unexpected input to mock")
+	}
+
+	return c.mockAddUserSearchBookmarkCfg.returnedError
+}
+
+// DeleteUserSearchBookmark implements BackendSpannerClient.
+func (c mockBackendSpannerClient) DeleteUserSearchBookmark(
+	_ context.Context, req gcpspanner.UserSavedSearchBookmark) error {
+	if !reflect.DeepEqual(req, c.mockDeleteUserSearchBookmarkCfg.expectedRequest) {
+		c.t.Error("unexpected input to mock")
+	}
+
+	return c.mockDeleteUserSearchBookmarkCfg.returnedError
+}
+
 func (c mockBackendSpannerClient) ListUserSavedSearches(
 	_ context.Context, userID string, pageSize int, pageToken *string) (*gcpspanner.UserSavedSearchesPage, error) {
 	if userID != c.mockListUserSavedSearchesCfg.expectedUserID ||
@@ -2401,6 +2433,134 @@ func TestUpdateUserSavedSearch(t *testing.T) {
 	}
 }
 
+// nolint: dupl // WONTFIX
+func TestAddUserSavedSearchBookmark(t *testing.T) {
+	userID := "test-add-user"
+	savedSearchID := "test-add-id"
+	bookmark := gcpspanner.UserSavedSearchBookmark{
+		UserID:        "test-add-user",
+		SavedSearchID: "test-add-id",
+	}
+	testCases := []struct {
+		name        string
+		cfg         *mockAddUserSearchBookmarkConfig
+		expectedErr error
+	}{
+		{
+			name: "success",
+			cfg: &mockAddUserSearchBookmarkConfig{
+				expectedRequest: bookmark,
+				returnedError:   nil,
+			},
+			expectedErr: nil,
+		},
+		{
+			name: "limit exceeded error",
+			cfg: &mockAddUserSearchBookmarkConfig{
+				expectedRequest: bookmark,
+				returnedError:   gcpspanner.ErrUserSearchBookmarkLimitExceeded,
+			},
+			expectedErr: backendtypes.ErrUserMaxBookmarks,
+		},
+		{
+			name: "not found error",
+			cfg: &mockAddUserSearchBookmarkConfig{
+				expectedRequest: bookmark,
+				returnedError:   gcpspanner.ErrQueryReturnedNoResults,
+			},
+			expectedErr: backendtypes.ErrEntityDoesNotExist,
+		},
+		{
+			name: "unknown error",
+			cfg: &mockAddUserSearchBookmarkConfig{
+				expectedRequest: bookmark,
+				returnedError:   errTest,
+			},
+			expectedErr: errTest,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			//nolint: exhaustruct
+			mock := mockBackendSpannerClient{
+				t:                            t,
+				mockAddUserSearchBookmarkCfg: tc.cfg,
+			}
+			bk := NewBackend(mock)
+			err := bk.PutUserSavedSearchBookmark(context.Background(), userID, savedSearchID)
+
+			if !errors.Is(err, tc.expectedErr) {
+				t.Errorf("unexpected error %s", err)
+			}
+		})
+	}
+}
+
+// nolint: dupl // WONTFIX
+func TestRemoveUserSavedSearchBookmark(t *testing.T) {
+	userID := "test-remove-user"
+	savedSearchID := "test-remove-id"
+	bookmark := gcpspanner.UserSavedSearchBookmark{
+		UserID:        "test-remove-user",
+		SavedSearchID: "test-remove-id",
+	}
+	testCases := []struct {
+		name        string
+		cfg         *mockDeleteUserSearchBookmarkConfig
+		expectedErr error
+	}{
+		{
+			name: "success",
+			cfg: &mockDeleteUserSearchBookmarkConfig{
+				expectedRequest: bookmark,
+				returnedError:   nil,
+			},
+			expectedErr: nil,
+		},
+		{
+			name: "owner cannot delete bookmark error",
+			cfg: &mockDeleteUserSearchBookmarkConfig{
+				expectedRequest: bookmark,
+				returnedError:   gcpspanner.ErrOwnerCannotDeleteBookmark,
+			},
+			expectedErr: backendtypes.ErrUserNotAuthorizedForAction,
+		},
+		{
+			name: "not found error",
+			cfg: &mockDeleteUserSearchBookmarkConfig{
+				expectedRequest: bookmark,
+				returnedError:   gcpspanner.ErrQueryReturnedNoResults,
+			},
+			expectedErr: backendtypes.ErrEntityDoesNotExist,
+		},
+		{
+			name: "unknown error",
+			cfg: &mockDeleteUserSearchBookmarkConfig{
+				expectedRequest: bookmark,
+				returnedError:   errTest,
+			},
+			expectedErr: errTest,
+		},
+	}
+
+	for _, tc := range testCases {
+		t.Run(tc.name, func(t *testing.T) {
+			//nolint: exhaustruct
+			mock := mockBackendSpannerClient{
+				t:                               t,
+				mockDeleteUserSearchBookmarkCfg: tc.cfg,
+			}
+			bk := NewBackend(mock)
+			err := bk.RemoveUserSavedSearchBookmark(context.Background(), userID, savedSearchID)
+
+			if !errors.Is(err, tc.expectedErr) {
+				t.Errorf("unexpected error %s", err)
+			}
+		})
+	}
+}
+
 func TestBuildUpdateSavedSearchRequestForGCP(t *testing.T) {
 	testSavedSearchID := "test-id"
 	testUserID := "test-user"

lib/gcpspanner/spanneradapters/backendtypes/types.go

@@ -26,6 +26,10 @@ var (
 	// number of allowed saved searches.
 	ErrUserMaxSavedSearches = errors.New("user has reached the maximum number of allowed saved searches")
 
+	// ErrUserMaxBookmarks indicates the user has reached the maximum
+	// number of allowed bookmarks.
+	ErrUserMaxBookmarks = errors.New("user has reached the maximum number of allowed bookmarks")
+
 	// ErrUserNotAuthorizedForAction indicates the user is not authorized to execute the requested action.
 	ErrUserNotAuthorizedForAction = errors.New("user not authorized to execute action")