954 lines
26 KiB
Go
954 lines
26 KiB
Go
package test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/protobuf/types/known/fieldmaskpb"
|
|
|
|
v1pb "github.com/usememos/memos/proto/gen/api/v1"
|
|
)
|
|
|
|
func TestListMemoViews(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
t.Run("ListMemoViews success", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create a user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// List memoViews (should be empty initially)
|
|
req := &v1pb.ListMemoViewsRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
}
|
|
|
|
resp, err := ts.Service.ListMemoViews(userCtx, req)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, resp)
|
|
require.Empty(t, resp.MemoViews)
|
|
})
|
|
|
|
t.Run("ListMemoViews permission denied for different user", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create two users
|
|
user1, err := ts.CreateRegularUser(ctx, "user1")
|
|
require.NoError(t, err)
|
|
user2, err := ts.CreateRegularUser(ctx, "user2")
|
|
require.NoError(t, err)
|
|
|
|
// Set user1 context but try to list user2's memoViews
|
|
userCtx := ts.CreateUserContext(ctx, user1.ID)
|
|
|
|
req := &v1pb.ListMemoViewsRequest{
|
|
Parent: fmt.Sprintf("users/%s", user2.Username),
|
|
}
|
|
|
|
_, err = ts.Service.ListMemoViews(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "permission denied")
|
|
})
|
|
|
|
t.Run("ListMemoViews invalid parent format", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.ListMemoViewsRequest{
|
|
Parent: "invalid-parent-format",
|
|
}
|
|
|
|
_, err = ts.Service.ListMemoViews(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "invalid user name")
|
|
})
|
|
|
|
t.Run("ListMemoViews unauthenticated", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
_, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
req := &v1pb.ListMemoViewsRequest{
|
|
Parent: "users/testuser",
|
|
}
|
|
|
|
_, err = ts.Service.ListMemoViews(ctx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "user not authenticated")
|
|
})
|
|
|
|
t.Run("ListMemoViews returns not found for numeric parent", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
_, err = ts.Service.ListMemoViews(userCtx, &v1pb.ListMemoViewsRequest{
|
|
Parent: "users/1",
|
|
})
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "user not found")
|
|
})
|
|
}
|
|
|
|
func TestGetMemoView(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
t.Run("GetMemoView success", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create a user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// First create a memoView
|
|
createReq := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Test MemoView",
|
|
Filter: "tag in [\"test\"]",
|
|
},
|
|
}
|
|
|
|
created, err := ts.Service.CreateMemoView(userCtx, createReq)
|
|
require.NoError(t, err)
|
|
|
|
// Now get the memoView
|
|
getReq := &v1pb.GetMemoViewRequest{
|
|
Name: created.Name,
|
|
}
|
|
|
|
resp, err := ts.Service.GetMemoView(userCtx, getReq)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, resp)
|
|
require.Equal(t, created.Name, resp.Name)
|
|
require.Equal(t, "Test MemoView", resp.Title)
|
|
require.Equal(t, "tag in [\"test\"]", resp.Filter)
|
|
})
|
|
|
|
t.Run("GetMemoView permission denied for different user", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create two users
|
|
user1, err := ts.CreateRegularUser(ctx, "user1")
|
|
require.NoError(t, err)
|
|
user2, err := ts.CreateRegularUser(ctx, "user2")
|
|
require.NoError(t, err)
|
|
|
|
// Create memoView as user1
|
|
user1Ctx := ts.CreateUserContext(ctx, user1.ID)
|
|
createReq := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user1.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "User1 MemoView",
|
|
Filter: "tag in [\"user1\"]",
|
|
},
|
|
}
|
|
|
|
created, err := ts.Service.CreateMemoView(user1Ctx, createReq)
|
|
require.NoError(t, err)
|
|
|
|
// Try to get memoView as user2
|
|
user2Ctx := ts.CreateUserContext(ctx, user2.ID)
|
|
getReq := &v1pb.GetMemoViewRequest{
|
|
Name: created.Name,
|
|
}
|
|
|
|
_, err = ts.Service.GetMemoView(user2Ctx, getReq)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "permission denied")
|
|
})
|
|
|
|
t.Run("GetMemoView invalid name format", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.GetMemoViewRequest{
|
|
Name: "invalid-memo-view-name",
|
|
}
|
|
|
|
_, err = ts.Service.GetMemoView(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "invalid memo view name")
|
|
})
|
|
|
|
t.Run("GetMemoView not found", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.GetMemoViewRequest{
|
|
Name: fmt.Sprintf("users/%s", user.Username) + "/views/nonexistent",
|
|
}
|
|
|
|
_, err = ts.Service.GetMemoView(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "not found")
|
|
})
|
|
}
|
|
|
|
func TestCreateMemoView(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
t.Run("CreateMemoView success", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create a user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "My MemoView",
|
|
Filter: "tag in [\"important\"]",
|
|
},
|
|
}
|
|
|
|
resp, err := ts.Service.CreateMemoView(userCtx, req)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, resp)
|
|
require.Equal(t, "My MemoView", resp.Title)
|
|
require.Equal(t, "tag in [\"important\"]", resp.Filter)
|
|
require.Contains(t, resp.Name, fmt.Sprintf("users/%s/views/", user.Username))
|
|
|
|
// Verify the memoView was created by listing
|
|
listReq := &v1pb.ListMemoViewsRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
}
|
|
|
|
listResp, err := ts.Service.ListMemoViews(userCtx, listReq)
|
|
require.NoError(t, err)
|
|
require.Len(t, listResp.MemoViews, 1)
|
|
require.Equal(t, "My MemoView", listResp.MemoViews[0].Title)
|
|
})
|
|
|
|
t.Run("CreateMemoView permission denied for different user", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create two users
|
|
user1, err := ts.CreateRegularUser(ctx, "user1")
|
|
require.NoError(t, err)
|
|
user2, err := ts.CreateRegularUser(ctx, "user2")
|
|
require.NoError(t, err)
|
|
|
|
// Set user1 context but try to create memoView for user2
|
|
userCtx := ts.CreateUserContext(ctx, user1.ID)
|
|
|
|
req := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user2.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Forbidden MemoView",
|
|
Filter: "tag in [\"forbidden\"]",
|
|
},
|
|
}
|
|
|
|
_, err = ts.Service.CreateMemoView(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "permission denied")
|
|
})
|
|
|
|
t.Run("CreateMemoView invalid parent format", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.CreateMemoViewRequest{
|
|
Parent: "invalid-parent",
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Test MemoView",
|
|
Filter: "tag in [\"test\"]",
|
|
},
|
|
}
|
|
|
|
_, err = ts.Service.CreateMemoView(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "invalid user name")
|
|
})
|
|
|
|
t.Run("CreateMemoView invalid filter", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Invalid Filter MemoView",
|
|
Filter: "invalid||filter))syntax",
|
|
},
|
|
}
|
|
|
|
_, err = ts.Service.CreateMemoView(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "invalid filter")
|
|
})
|
|
|
|
t.Run("CreateMemoView missing title", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Filter: "tag in [\"test\"]",
|
|
},
|
|
}
|
|
|
|
_, err = ts.Service.CreateMemoView(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "title is required")
|
|
})
|
|
}
|
|
|
|
func TestUpdateMemoView(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
t.Run("UpdateMemoView success", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create a user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// Create a memoView first
|
|
createReq := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Original Title",
|
|
Filter: "tag in [\"original\"]",
|
|
},
|
|
}
|
|
|
|
created, err := ts.Service.CreateMemoView(userCtx, createReq)
|
|
require.NoError(t, err)
|
|
|
|
// Update the memoView
|
|
updateReq := &v1pb.UpdateMemoViewRequest{
|
|
MemoView: &v1pb.MemoView{
|
|
Name: created.Name,
|
|
Title: "Updated Title",
|
|
Filter: "tag in [\"updated\"]",
|
|
},
|
|
UpdateMask: &fieldmaskpb.FieldMask{
|
|
Paths: []string{"title", "filter"},
|
|
},
|
|
}
|
|
|
|
updated, err := ts.Service.UpdateMemoView(userCtx, updateReq)
|
|
require.NoError(t, err)
|
|
require.NotNil(t, updated)
|
|
require.Equal(t, "Updated Title", updated.Title)
|
|
require.Equal(t, "tag in [\"updated\"]", updated.Filter)
|
|
require.Equal(t, created.Name, updated.Name)
|
|
})
|
|
|
|
t.Run("UpdateMemoView permission denied for different user", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create two users
|
|
user1, err := ts.CreateRegularUser(ctx, "user1")
|
|
require.NoError(t, err)
|
|
user2, err := ts.CreateRegularUser(ctx, "user2")
|
|
require.NoError(t, err)
|
|
|
|
// Create memoView as user1
|
|
user1Ctx := ts.CreateUserContext(ctx, user1.ID)
|
|
createReq := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user1.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "User1 MemoView",
|
|
Filter: "tag in [\"user1\"]",
|
|
},
|
|
}
|
|
|
|
created, err := ts.Service.CreateMemoView(user1Ctx, createReq)
|
|
require.NoError(t, err)
|
|
|
|
// Try to update memoView as user2
|
|
user2Ctx := ts.CreateUserContext(ctx, user2.ID)
|
|
updateReq := &v1pb.UpdateMemoViewRequest{
|
|
MemoView: &v1pb.MemoView{
|
|
Name: created.Name,
|
|
Title: "Hacked Title",
|
|
Filter: "tag in [\"hacked\"]",
|
|
},
|
|
UpdateMask: &fieldmaskpb.FieldMask{
|
|
Paths: []string{"title", "filter"},
|
|
},
|
|
}
|
|
|
|
_, err = ts.Service.UpdateMemoView(user2Ctx, updateReq)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "permission denied")
|
|
})
|
|
|
|
t.Run("UpdateMemoView missing update mask", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create a user and context for authentication
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.UpdateMemoViewRequest{
|
|
MemoView: &v1pb.MemoView{
|
|
Name: fmt.Sprintf("users/%s/views/test", user.Username),
|
|
Title: "Updated Title",
|
|
},
|
|
}
|
|
|
|
_, err = ts.Service.UpdateMemoView(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "update mask is required")
|
|
})
|
|
|
|
t.Run("UpdateMemoView rejects unsupported update mask paths", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
created, err := ts.Service.CreateMemoView(userCtx, &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Original Title",
|
|
Filter: `tag in ["original"]`,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.Service.UpdateMemoView(userCtx, &v1pb.UpdateMemoViewRequest{
|
|
MemoView: created,
|
|
UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"name"}},
|
|
})
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "unsupported update mask path: name")
|
|
})
|
|
|
|
t.Run("UpdateMemoView invalid name format", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
req := &v1pb.UpdateMemoViewRequest{
|
|
MemoView: &v1pb.MemoView{
|
|
Name: "invalid-memo-view-name",
|
|
Title: "Updated Title",
|
|
},
|
|
UpdateMask: &fieldmaskpb.FieldMask{
|
|
Paths: []string{"title"},
|
|
},
|
|
}
|
|
|
|
_, err := ts.Service.UpdateMemoView(ctx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "invalid memo view name")
|
|
})
|
|
|
|
t.Run("UpdateMemoView invalid filter", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// Create a memoView first
|
|
createReq := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Test MemoView",
|
|
Filter: "tag in [\"test\"]",
|
|
},
|
|
}
|
|
|
|
created, err := ts.Service.CreateMemoView(userCtx, createReq)
|
|
require.NoError(t, err)
|
|
|
|
// Try to update with invalid filter
|
|
updateReq := &v1pb.UpdateMemoViewRequest{
|
|
MemoView: &v1pb.MemoView{
|
|
Name: created.Name,
|
|
Filter: "invalid||filter))syntax",
|
|
},
|
|
UpdateMask: &fieldmaskpb.FieldMask{
|
|
Paths: []string{"filter"},
|
|
},
|
|
}
|
|
|
|
_, err = ts.Service.UpdateMemoView(userCtx, updateReq)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "invalid filter")
|
|
})
|
|
}
|
|
|
|
func TestDeleteMemoView(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
t.Run("DeleteMemoView success", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create a user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// Create a memoView first
|
|
createReq := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "MemoView to Delete",
|
|
Filter: "tag in [\"delete\"]",
|
|
},
|
|
}
|
|
|
|
created, err := ts.Service.CreateMemoView(userCtx, createReq)
|
|
require.NoError(t, err)
|
|
|
|
// Delete the memoView
|
|
deleteReq := &v1pb.DeleteMemoViewRequest{
|
|
Name: created.Name,
|
|
}
|
|
|
|
_, err = ts.Service.DeleteMemoView(userCtx, deleteReq)
|
|
require.NoError(t, err)
|
|
|
|
// Verify deletion by listing memoViews
|
|
listReq := &v1pb.ListMemoViewsRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
}
|
|
|
|
listResp, err := ts.Service.ListMemoViews(userCtx, listReq)
|
|
require.NoError(t, err)
|
|
require.Empty(t, listResp.MemoViews)
|
|
|
|
// Also verify by trying to get the deleted memoView
|
|
getReq := &v1pb.GetMemoViewRequest{
|
|
Name: created.Name,
|
|
}
|
|
|
|
_, err = ts.Service.GetMemoView(userCtx, getReq)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "not found")
|
|
})
|
|
|
|
t.Run("DeleteMemoView permission denied for different user", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create two users
|
|
user1, err := ts.CreateRegularUser(ctx, "user1")
|
|
require.NoError(t, err)
|
|
user2, err := ts.CreateRegularUser(ctx, "user2")
|
|
require.NoError(t, err)
|
|
|
|
// Create memoView as user1
|
|
user1Ctx := ts.CreateUserContext(ctx, user1.ID)
|
|
createReq := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user1.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "User1 MemoView",
|
|
Filter: "tag in [\"user1\"]",
|
|
},
|
|
}
|
|
|
|
created, err := ts.Service.CreateMemoView(user1Ctx, createReq)
|
|
require.NoError(t, err)
|
|
|
|
// Try to delete memoView as user2
|
|
user2Ctx := ts.CreateUserContext(ctx, user2.ID)
|
|
deleteReq := &v1pb.DeleteMemoViewRequest{
|
|
Name: created.Name,
|
|
}
|
|
|
|
_, err = ts.Service.DeleteMemoView(user2Ctx, deleteReq)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "permission denied")
|
|
})
|
|
|
|
t.Run("DeleteMemoView invalid name format", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
req := &v1pb.DeleteMemoViewRequest{
|
|
Name: "invalid-memo-view-name",
|
|
}
|
|
|
|
_, err := ts.Service.DeleteMemoView(ctx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "invalid memo view name")
|
|
})
|
|
|
|
t.Run("DeleteMemoView not found", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.DeleteMemoViewRequest{
|
|
Name: fmt.Sprintf("users/%s", user.Username) + "/views/nonexistent",
|
|
}
|
|
|
|
_, err = ts.Service.DeleteMemoView(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "not found")
|
|
})
|
|
}
|
|
|
|
func TestMemoViewFiltering(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
t.Run("CreateMemoView with valid filters", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// Test various valid filter formats
|
|
validFilters := []string{
|
|
"tag in [\"work\"]",
|
|
"content.contains(\"meeting\")",
|
|
"tag in [\"work\"] && content.contains(\"meeting\")",
|
|
"tag in [\"work\"] || tag in [\"personal\"]",
|
|
"creator_id == 1",
|
|
"visibility == \"PUBLIC\"",
|
|
"has_task_list == true",
|
|
"has_task_list == false",
|
|
}
|
|
|
|
for i, filter := range validFilters {
|
|
req := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: fmt.Sprintf("Valid Filter %d", i),
|
|
Filter: filter,
|
|
},
|
|
}
|
|
|
|
_, err = ts.Service.CreateMemoView(userCtx, req)
|
|
require.NoError(t, err, "Filter should be valid: %s", filter)
|
|
}
|
|
})
|
|
|
|
t.Run("CreateMemoView with invalid filters", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// Test various invalid filter formats
|
|
invalidFilters := []string{
|
|
"tag in ", // incomplete expression
|
|
"invalid_field @in [\"value\"]", // unknown field
|
|
"tag in [\"work\"] &&", // incomplete expression
|
|
"tag in [\"work\"] || || tag in [\"test\"]", // double operator
|
|
"((tag in [\"work\"]", // unmatched parentheses
|
|
"tag in [\"work\"] && )", // mismatched parentheses
|
|
"tag == \"work\"", // wrong operator (== not supported for tags)
|
|
"tag in work", // missing brackets
|
|
}
|
|
|
|
for _, filter := range invalidFilters {
|
|
req := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Invalid Filter Test",
|
|
Filter: filter,
|
|
},
|
|
}
|
|
|
|
_, err = ts.Service.CreateMemoView(userCtx, req)
|
|
require.Error(t, err, "Filter should be invalid: %s", filter)
|
|
require.Contains(t, err.Error(), "invalid filter", "Error should mention invalid filter for: %s", filter)
|
|
}
|
|
})
|
|
}
|
|
|
|
func TestMemoViewCRUDComplete(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
t.Run("Complete CRUD lifecycle", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
// Create user
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
|
|
// Set user context
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
// 1. Create multiple memoViews
|
|
memoView1Req := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Work Notes",
|
|
Filter: "tag in [\"work\"]",
|
|
},
|
|
}
|
|
|
|
memoView2Req := &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Personal Notes",
|
|
Filter: "tag in [\"personal\"]",
|
|
},
|
|
}
|
|
|
|
created1, err := ts.Service.CreateMemoView(userCtx, memoView1Req)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "Work Notes", created1.Title)
|
|
|
|
created2, err := ts.Service.CreateMemoView(userCtx, memoView2Req)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "Personal Notes", created2.Title)
|
|
|
|
// 2. List memoViews and verify both exist
|
|
listReq := &v1pb.ListMemoViewsRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
}
|
|
|
|
listResp, err := ts.Service.ListMemoViews(userCtx, listReq)
|
|
require.NoError(t, err)
|
|
require.Len(t, listResp.MemoViews, 2)
|
|
|
|
// 3. Get individual memoViews
|
|
getReq1 := &v1pb.GetMemoViewRequest{Name: created1.Name}
|
|
getResp1, err := ts.Service.GetMemoView(userCtx, getReq1)
|
|
require.NoError(t, err)
|
|
require.Equal(t, created1.Name, getResp1.Name)
|
|
require.Equal(t, "Work Notes", getResp1.Title)
|
|
|
|
getReq2 := &v1pb.GetMemoViewRequest{Name: created2.Name}
|
|
getResp2, err := ts.Service.GetMemoView(userCtx, getReq2)
|
|
require.NoError(t, err)
|
|
require.Equal(t, created2.Name, getResp2.Name)
|
|
require.Equal(t, "Personal Notes", getResp2.Title)
|
|
|
|
// 4. Update one memoView
|
|
updateReq := &v1pb.UpdateMemoViewRequest{
|
|
MemoView: &v1pb.MemoView{
|
|
Name: created1.Name,
|
|
Title: "Work & Meeting Notes",
|
|
Filter: "tag in [\"work\"] || tag in [\"meeting\"]",
|
|
},
|
|
UpdateMask: &fieldmaskpb.FieldMask{
|
|
Paths: []string{"title", "filter"},
|
|
},
|
|
}
|
|
|
|
updated, err := ts.Service.UpdateMemoView(userCtx, updateReq)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "Work & Meeting Notes", updated.Title)
|
|
require.Equal(t, "tag in [\"work\"] || tag in [\"meeting\"]", updated.Filter)
|
|
|
|
// 5. Verify update by getting it again
|
|
getUpdatedReq := &v1pb.GetMemoViewRequest{Name: created1.Name}
|
|
getUpdatedResp, err := ts.Service.GetMemoView(userCtx, getUpdatedReq)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "Work & Meeting Notes", getUpdatedResp.Title)
|
|
require.Equal(t, "tag in [\"work\"] || tag in [\"meeting\"]", getUpdatedResp.Filter)
|
|
|
|
// 6. Delete one memoView
|
|
deleteReq := &v1pb.DeleteMemoViewRequest{
|
|
Name: created2.Name,
|
|
}
|
|
|
|
_, err = ts.Service.DeleteMemoView(userCtx, deleteReq)
|
|
require.NoError(t, err)
|
|
|
|
// 7. Verify deletion by listing (should only have 1 left)
|
|
finalListResp, err := ts.Service.ListMemoViews(userCtx, listReq)
|
|
require.NoError(t, err)
|
|
require.Len(t, finalListResp.MemoViews, 1)
|
|
require.Equal(t, "Work & Meeting Notes", finalListResp.MemoViews[0].Title)
|
|
|
|
// 8. Verify deleted memoView can't be accessed
|
|
getDeletedReq := &v1pb.GetMemoViewRequest{Name: created2.Name}
|
|
_, err = ts.Service.GetMemoView(userCtx, getDeletedReq)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "not found")
|
|
})
|
|
}
|
|
|
|
func TestMemoViewRegressions(t *testing.T) {
|
|
ctx := context.Background()
|
|
|
|
t.Run("UpdateMemoView rejects a missing memo view instead of panicking", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
req := &v1pb.UpdateMemoViewRequest{
|
|
UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title"}},
|
|
}
|
|
|
|
_, err = ts.Service.UpdateMemoView(userCtx, req)
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "invalid memo view name")
|
|
})
|
|
|
|
t.Run("UpdateMemoView leaves the stored view untouched when validation fails", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
created, err := ts.Service.CreateMemoView(userCtx, &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: "Original Title",
|
|
Filter: `tag in ["work"]`,
|
|
},
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
// The title path is applied before the filter path is validated. A rejected
|
|
// filter must not leave the new title behind.
|
|
_, err = ts.Service.UpdateMemoView(userCtx, &v1pb.UpdateMemoViewRequest{
|
|
MemoView: &v1pb.MemoView{
|
|
Name: created.Name,
|
|
Title: "Phantom Title",
|
|
Filter: "this is not (((a valid filter",
|
|
},
|
|
UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"title", "filter"}},
|
|
})
|
|
require.Error(t, err)
|
|
require.Contains(t, err.Error(), "invalid filter")
|
|
|
|
got, err := ts.Service.GetMemoView(userCtx, &v1pb.GetMemoViewRequest{Name: created.Name})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "Original Title", got.Title)
|
|
require.Equal(t, `tag in ["work"]`, got.Filter)
|
|
})
|
|
|
|
t.Run("CreateMemoView keeps every view under concurrent creates", func(t *testing.T) {
|
|
ts := NewTestService(t)
|
|
defer ts.Cleanup()
|
|
|
|
user, err := ts.CreateRegularUser(ctx, "testuser")
|
|
require.NoError(t, err)
|
|
userCtx := ts.CreateUserContext(ctx, user.ID)
|
|
|
|
const concurrency = 8
|
|
var wg sync.WaitGroup
|
|
errs := make([]error, concurrency)
|
|
for i := range concurrency {
|
|
wg.Go(func() {
|
|
_, errs[i] = ts.Service.CreateMemoView(userCtx, &v1pb.CreateMemoViewRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
MemoView: &v1pb.MemoView{
|
|
Title: fmt.Sprintf("View %d", i),
|
|
Filter: `tag in ["work"]`,
|
|
},
|
|
})
|
|
})
|
|
}
|
|
wg.Wait()
|
|
for _, err := range errs {
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
resp, err := ts.Service.ListMemoViews(userCtx, &v1pb.ListMemoViewsRequest{
|
|
Parent: fmt.Sprintf("users/%s", user.Username),
|
|
})
|
|
require.NoError(t, err)
|
|
require.Len(t, resp.MemoViews, concurrency)
|
|
})
|
|
}
|