Memos is an open-source, self-hosted note-taking app that brings your everyday thoughts together in a personal timeline. Your data stays yours, and you choose what to keep private or share.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
package test
import (
"context"
"testing"
"github.com/stretchr/testify/require"
"google.golang.org/protobuf/proto"
storepb "github.com/usememos/memos/proto/gen/store"
"github.com/usememos/memos/store"
)
type usageLimitEntry = storepb.InstanceUsageLimitsSetting_UsageLimit
func usageLimitsSetting(limits ...*usageLimitEntry) *storepb.InstanceUsageLimitsSetting {
return &storepb.InstanceUsageLimitsSetting{Limits: limits}
}
// writeUsageLimits stores limits through the generic instance setting write,
// which is the only write path the API has.
func writeUsageLimits(ctx context.Context, t *testing.T, ts *store.Store, limits ...*usageLimitEntry) {
t.Helper()
_, err := ts.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{
Key: storepb.InstanceSettingKey_USAGE_LIMITS,
Value: &storepb.InstanceSetting_UsageLimitsSetting{UsageLimitsSetting: usageLimitsSetting(limits...)},
})
require.NoError(t, err)
}
func storedUserIDs(ctx context.Context, t *testing.T, ts *store.Store) [][]int32 {
t.Helper()
setting, err := ts.GetInstanceUsageLimitsSetting(ctx)
require.NoError(t, err)
ids := [][]int32{}
for _, limit := range setting.Limits {
ids = append(ids, limit.UserIds)
}
return ids
}
func TestCountUserMemos(t *testing.T) {
t.Parallel()
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
owner, err := ts.CreateUser(ctx, &store.User{Username: "count-owner", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
other, err := ts.CreateUser(ctx, &store.User{Username: "count-other", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
count, err := ts.CountUserMemos(ctx, owner.ID)
require.NoError(t, err)
require.Zero(t, count)
root, err := ts.CreateMemo(ctx, &store.Memo{UID: "count-root", CreatorID: owner.ID, Content: "root", Visibility: store.Public})
require.NoError(t, err)
archived, err := ts.CreateMemo(ctx, &store.Memo{UID: "count-archived", CreatorID: owner.ID, Content: "archived", Visibility: store.Private})
require.NoError(t, err)
archivedStatus := store.Archived
require.NoError(t, ts.UpdateMemo(ctx, &store.UpdateMemo{ID: archived.ID, RowStatus: &archivedStatus}))
space, err := ts.CreateSpace(ctx, &store.Space{UID: "count-space", Title: "Count"}, owner.ID)
require.NoError(t, err)
_, err = ts.CreateMemo(ctx, &store.Memo{UID: "count-space-memo", CreatorID: owner.ID, Content: "space", Visibility: store.SpaceAudience, SpaceID: &space.ID})
require.NoError(t, err)
_, err = ts.CreateMemoComment(ctx, &store.Memo{UID: "count-comment", CreatorID: owner.ID, Content: "comment", Visibility: store.Public}, root.ID, owner.ID)
require.NoError(t, err)
_, err = ts.CreateMemo(ctx, &store.Memo{UID: "count-other-memo", CreatorID: other.ID, Content: "other", Visibility: store.Public})
require.NoError(t, err)
count, err = ts.CountUserMemos(ctx, owner.ID)
require.NoError(t, err)
require.Equal(t, int64(4), count, "archived memos, Space memos, and comments count; other users' memos do not")
require.NoError(t, ts.DeleteMemo(ctx, &store.DeleteMemo{ID: archived.ID}))
count, err = ts.CountUserMemos(ctx, owner.ID)
require.NoError(t, err)
require.Equal(t, int64(3), count, "deleting a memo frees a slot")
}
func TestUpdateInstanceSettingIfUnchanged(t *testing.T) {
t.Parallel()
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
driver := ts.GetDriver()
updated, err := driver.UpdateInstanceSettingIfUnchanged(ctx, "CONDITIONAL_TEST", "", "first")
require.NoError(t, err)
require.False(t, updated, "a missing row is never updated")
created, err := driver.CreateInstanceSettingIfNotExists(ctx, &store.InstanceSetting{Name: "CONDITIONAL_TEST", Value: "first"})
require.NoError(t, err)
require.True(t, created)
updated, err = driver.UpdateInstanceSettingIfUnchanged(ctx, "CONDITIONAL_TEST", "stale", "second")
require.NoError(t, err)
require.False(t, updated, "a stale old value must not overwrite")
updated, err = driver.UpdateInstanceSettingIfUnchanged(ctx, "CONDITIONAL_TEST", "FIRST", "second")
require.NoError(t, err)
require.False(t, updated, "the comparison is exact, including case")
updated, err = driver.UpdateInstanceSettingIfUnchanged(ctx, "CONDITIONAL_TEST", "first", "second")
require.NoError(t, err)
require.True(t, updated)
updated, err = driver.UpdateInstanceSettingIfUnchanged(ctx, "CONDITIONAL_TEST", "second", "second")
require.NoError(t, err)
require.True(t, updated, "writing the stored value again succeeds")
settings, err := driver.ListInstanceSettings(ctx, &store.FindInstanceSetting{Name: "CONDITIONAL_TEST"})
require.NoError(t, err)
require.Len(t, settings, 1)
require.Equal(t, "second", settings[0].Value)
}
func TestUsageLimitsDefaultSetting(t *testing.T) {
t.Parallel()
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
setting, err := ts.GetInstanceUsageLimitsSetting(ctx)
require.NoError(t, err)
require.Len(t, setting.Limits, 1)
require.True(t, setting.Limits[0].AllUsers)
require.Equal(t, store.DefaultUploadBytes, setting.Limits[0].GetUploadBytes())
require.Equal(t, store.DefaultMemoContentBytes, setting.Limits[0].GetMemoContentBytes())
require.Nil(t, setting.Limits[0].MemoCount)
require.Nil(t, setting.Limits[0].StorageBytes)
stored, err := ts.GetUncachedInstanceSetting(ctx, &store.FindInstanceSetting{Name: storepb.InstanceSettingKey_USAGE_LIMITS.String()})
require.NoError(t, err)
require.Nil(t, stored, "reading defaults does not persist a setting")
*setting.Limits[0].UploadBytes = 1
setting, err = ts.GetInstanceUsageLimitsSetting(ctx)
require.NoError(t, err)
require.Equal(t, store.DefaultUploadBytes, setting.Limits[0].GetUploadBytes(), "each read returns fresh defaults")
writeUsageLimits(ctx, t, ts, &usageLimitEntry{AllUsers: true, UploadBytes: new(int64(0))})
setting, err = ts.GetInstanceUsageLimitsSetting(ctx)
require.NoError(t, err)
require.Len(t, setting.Limits, 1)
require.Zero(t, setting.Limits[0].GetUploadBytes(), "an explicit zero is stored")
require.Nil(t, setting.Limits[0].MemoContentBytes, "the stored list is the whole truth; built-in defaults do not come back")
// The row round-trips through the generic setting reads too.
stored, err = ts.GetUncachedInstanceSetting(ctx, &store.FindInstanceSetting{Name: storepb.InstanceSettingKey_USAGE_LIMITS.String()})
require.NoError(t, err)
require.True(t, proto.Equal(setting, stored.GetUsageLimitsSetting()))
}
func TestValidateInstanceUsageLimitsSetting(t *testing.T) {
tooMany := make([]*usageLimitEntry, 0, store.MaxUsageLimitEntries+1)
for i := range store.MaxUsageLimitEntries {
tooMany = append(tooMany, &usageLimitEntry{UserIds: []int32{int32(i + 1)}})
}
tooMany = append(tooMany, &usageLimitEntry{AllUsers: true})
tooManyUsers := make([]int32, 0, store.MaxUsageLimitUsers+1)
for i := range store.MaxUsageLimitUsers + 1 {
tooManyUsers = append(tooManyUsers, int32(i+1))
}
require.NoError(t, store.ValidateInstanceUsageLimitsSetting(usageLimitsSetting(
&usageLimitEntry{UserIds: []int32{1, 2}, MemoCount: new(int64(0))},
&usageLimitEntry{UserIds: []int32{2}, StorageBytes: new(int64(1))},
&usageLimitEntry{AllUsers: true},
)), "a user may appear in several entries; the first wins")
require.NoError(t, store.ValidateInstanceUsageLimitsSetting(usageLimitsSetting(tooMany[1:]...)))
for name, setting := range map[string]*storepb.InstanceUsageLimitsSetting{
"nil": nil,
"empty": usageLimitsSetting(),
"no all-users entry": usageLimitsSetting(&usageLimitEntry{UserIds: []int32{1}}),
"all users not last": usageLimitsSetting(&usageLimitEntry{AllUsers: true}, &usageLimitEntry{UserIds: []int32{1}}),
"two all-users entries": usageLimitsSetting(&usageLimitEntry{AllUsers: true}, &usageLimitEntry{AllUsers: true}),
"users and all users": usageLimitsSetting(&usageLimitEntry{AllUsers: true, UserIds: []int32{1}}),
"entry without users": usageLimitsSetting(&usageLimitEntry{}, &usageLimitEntry{AllUsers: true}),
"nil entry": usageLimitsSetting(nil, &usageLimitEntry{AllUsers: true}),
"zero user ID": usageLimitsSetting(&usageLimitEntry{UserIds: []int32{0}}, &usageLimitEntry{AllUsers: true}),
"negative user ID": usageLimitsSetting(&usageLimitEntry{UserIds: []int32{-1}}, &usageLimitEntry{AllUsers: true}),
"repeated user in entry": usageLimitsSetting(&usageLimitEntry{UserIds: []int32{1, 1}}, &usageLimitEntry{AllUsers: true}),
"negative memo count": usageLimitsSetting(&usageLimitEntry{AllUsers: true, MemoCount: new(int64(-1))}),
"negative content bytes": usageLimitsSetting(&usageLimitEntry{AllUsers: true, MemoContentBytes: new(int64(-1))}),
"negative storage bytes": usageLimitsSetting(&usageLimitEntry{AllUsers: true, StorageBytes: new(int64(-1))}),
"negative upload bytes": usageLimitsSetting(&usageLimitEntry{AllUsers: true, UploadBytes: new(int64(-1))}),
"too many entries": usageLimitsSetting(tooMany...),
"too many users": usageLimitsSetting(&usageLimitEntry{UserIds: tooManyUsers}, &usageLimitEntry{AllUsers: true}),
"too many users in total": usageLimitsSetting(&usageLimitEntry{UserIds: tooManyUsers[:600]}, &usageLimitEntry{UserIds: tooManyUsers[600:]}, &usageLimitEntry{AllUsers: true}),
"all users with user list": usageLimitsSetting(&usageLimitEntry{UserIds: []int32{1}}, &usageLimitEntry{AllUsers: true, UserIds: []int32{2}}),
} {
t.Run(name, func(t *testing.T) {
require.ErrorIs(t, store.ValidateInstanceUsageLimitsSetting(setting), store.ErrInvalidUsageLimits)
})
}
}
func TestUpsertInstanceSettingValidatesUsageLimits(t *testing.T) {
t.Parallel()
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
_, err := ts.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{
Key: storepb.InstanceSettingKey_USAGE_LIMITS,
Value: &storepb.InstanceSetting_UsageLimitsSetting{UsageLimitsSetting: usageLimitsSetting(&usageLimitEntry{UserIds: []int32{1}})},
})
require.ErrorIs(t, err, store.ErrInvalidUsageLimits)
stored, err := ts.GetUncachedInstanceSetting(ctx, &store.FindInstanceSetting{Name: storepb.InstanceSettingKey_USAGE_LIMITS.String()})
require.NoError(t, err)
require.Nil(t, stored, "an invalid write stores nothing")
// A row that became invalid outside the store fails closed instead of
// silently removing every limit.
_, err = ts.GetDriver().UpsertInstanceSetting(ctx, &store.InstanceSetting{
Name: storepb.InstanceSettingKey_USAGE_LIMITS.String(),
Value: `{"limits":[{"userIds":[1],"memoCount":"1"}]}`,
})
require.NoError(t, err)
_, err = ts.GetInstanceUsageLimitsSetting(ctx)
require.ErrorIs(t, err, store.ErrInvalidUsageLimits)
}
func TestDeleteUserRemovesFromUsageLimits(t *testing.T) {
t.Parallel()
ctx := context.Background()
ts := NewTestingStore(ctx, t)
defer ts.Close()
alice, err := ts.CreateUser(ctx, &store.User{Username: "delete-alice", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
bob, err := ts.CreateUser(ctx, &store.User{Username: "delete-bob", Role: store.RoleUser, PasswordHash: "hash"})
require.NoError(t, err)
writeUsageLimits(ctx, t, ts,
&usageLimitEntry{UserIds: []int32{alice.ID, bob.ID}, StorageBytes: new(int64(5 << 30))},
&usageLimitEntry{UserIds: []int32{alice.ID}, MemoCount: new(int64(10))},
&usageLimitEntry{UserIds: []int32{bob.ID}, MemoCount: new(int64(20))},
&usageLimitEntry{AllUsers: true, StorageBytes: new(int64(1 << 30))},
)
_, err = ts.DeleteUser(ctx, &store.DeleteUser{ID: alice.ID})
require.NoError(t, err)
require.Equal(t, [][]int32{{bob.ID}, {bob.ID}, nil}, storedUserIDs(ctx, t, ts), "the user leaves shared entries and takes entries of their own with them")
setting, err := ts.GetInstanceUsageLimitsSetting(ctx)
require.NoError(t, err)
require.Equal(t, int64(5<<30), setting.Limits[0].GetStorageBytes())
require.True(t, setting.Limits[2].AllUsers)
require.NoError(t, ts.RemoveUserFromUsageLimits(ctx, 99999), "an unknown user is a no-op")
require.Equal(t, [][]int32{{bob.ID}, {bob.ID}, nil}, storedUserIDs(ctx, t, ts))
}