mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 10:29:11 +01:00
5f3969a830
Let people use any Unicode emoji through a searchable, virtualized picker. Keep reaction counts accurate and requests optimistic and idempotent. Refresh demo content so signed-in visitors can participate. BREAKING CHANGE: Remove the MEMO_RELATED instance setting and memoRelatedSetting configuration value. Remove their declarations and lifecycle references from configuration files; existing reactions are preserved.
222 lines
9.3 KiB
Go
222 lines
9.3 KiB
Go
package test
|
|
|
|
import (
|
|
"context"
|
|
"fmt"
|
|
"sync"
|
|
"testing"
|
|
|
|
"github.com/pkg/errors"
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/protobuf/proto"
|
|
|
|
storepb "github.com/usememos/memos/proto/gen/store"
|
|
"github.com/usememos/memos/store"
|
|
)
|
|
|
|
func managedResource(name string) *storepb.InstanceConfigurationState_ManagedResource {
|
|
return &storepb.InstanceConfigurationState_ManagedResource{
|
|
Name: name,
|
|
Kind: "InstanceSetting",
|
|
Source: "instance.json",
|
|
ManagedFields: []string{"*"},
|
|
}
|
|
}
|
|
|
|
func TestConfigurationStateSerial(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
t.Cleanup(func() { require.NoError(t, ts.Close()) })
|
|
|
|
initial, err := ts.GetConfigurationState(ctx)
|
|
require.NoError(t, err)
|
|
require.Zero(t, initial.Serial, "before any apply the record is empty")
|
|
require.Empty(t, initial.Resources)
|
|
|
|
// The first change creates the row with serial 1, whatever serial the body sets.
|
|
stored, err := ts.RunConfigurationTransaction(ctx, func(_ context.Context, tx *store.ConfigurationTransaction) (*storepb.InstanceConfigurationState, error) {
|
|
require.Zero(t, tx.State().Serial)
|
|
return &storepb.InstanceConfigurationState{Serial: 99, ConfigDigest: "a", Resources: []*storepb.InstanceConfigurationState_ManagedResource{
|
|
managedResource("instance/settings/ACCESS"),
|
|
}}, nil
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(1), stored.Serial)
|
|
|
|
// A body with no change commits nothing and keeps the serial.
|
|
unchanged, err := ts.RunConfigurationTransaction(ctx, func(_ context.Context, tx *store.ConfigurationTransaction) (*storepb.InstanceConfigurationState, error) {
|
|
require.Equal(t, int64(1), tx.State().Serial)
|
|
return nil, nil
|
|
})
|
|
require.NoError(t, err)
|
|
require.True(t, proto.Equal(stored, unchanged))
|
|
|
|
// A failing body rolls back.
|
|
failure := errors.New("plan failed")
|
|
_, err = ts.RunConfigurationTransaction(ctx, func(context.Context, *store.ConfigurationTransaction) (*storepb.InstanceConfigurationState, error) {
|
|
return &storepb.InstanceConfigurationState{ConfigDigest: "discarded"}, failure
|
|
})
|
|
require.ErrorIs(t, err, failure)
|
|
|
|
// A second change updates the row.
|
|
stored, err = ts.RunConfigurationTransaction(ctx, func(_ context.Context, tx *store.ConfigurationTransaction) (*storepb.InstanceConfigurationState, error) {
|
|
next := tx.State()
|
|
next.ConfigDigest = "b"
|
|
next.Resources = append(next.Resources, managedResource("instance/settings/GENERAL"))
|
|
return next, nil
|
|
})
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(2), stored.Serial)
|
|
|
|
read, err := ts.GetConfigurationState(ctx)
|
|
require.NoError(t, err)
|
|
require.True(t, proto.Equal(stored, read))
|
|
require.Equal(t, "b", read.ConfigDigest)
|
|
require.Len(t, read.Resources, 2)
|
|
}
|
|
|
|
func TestConfigurationStateIsNotAnInstanceSetting(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
t.Cleanup(func() { require.NoError(t, ts.Close()) })
|
|
|
|
_, err := ts.RunConfigurationTransaction(ctx, func(context.Context, *store.ConfigurationTransaction) (*storepb.InstanceConfigurationState, error) {
|
|
return &storepb.InstanceConfigurationState{Resources: []*storepb.InstanceConfigurationState_ManagedResource{managedResource("instance/settings/ACCESS")}}, nil
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
settings, err := ts.ListInstanceSettings(ctx, &store.FindInstanceSetting{})
|
|
require.NoError(t, err)
|
|
for _, setting := range settings {
|
|
require.NotEqual(t, storepb.InstanceSettingKey_CONFIGURATION_STATE, setting.Key)
|
|
}
|
|
setting, err := ts.GetInstanceSetting(ctx, &store.FindInstanceSetting{Name: storepb.InstanceSettingKey_CONFIGURATION_STATE.String()})
|
|
require.NoError(t, err)
|
|
require.Nil(t, setting)
|
|
}
|
|
|
|
// TestConfigurationStateConcurrentApplies runs transactions that each add one
|
|
// managed resource, as replicas starting together each apply at boot.
|
|
// Serializable isolation plus the conditional write must serialize them, and
|
|
// the retries must absorb the conflicts: every transaction commits once and
|
|
// none overwrites another.
|
|
func TestConfigurationStateConcurrentApplies(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
t.Cleanup(func() { require.NoError(t, ts.Close()) })
|
|
|
|
const applies = 6
|
|
var wg sync.WaitGroup
|
|
errs := make(chan error, applies)
|
|
for i := range applies {
|
|
wg.Go(func() {
|
|
_, err := ts.RunConfigurationTransaction(ctx, func(_ context.Context, tx *store.ConfigurationTransaction) (*storepb.InstanceConfigurationState, error) {
|
|
next := tx.State()
|
|
next.Resources = append(next.Resources, managedResource(fmt.Sprintf("users/user-%d", i)))
|
|
return next, nil
|
|
})
|
|
errs <- err
|
|
})
|
|
}
|
|
wg.Wait()
|
|
close(errs)
|
|
|
|
for err := range errs {
|
|
require.NoError(t, err)
|
|
}
|
|
state, err := ts.GetConfigurationState(ctx)
|
|
require.NoError(t, err)
|
|
require.Equal(t, int64(applies), state.Serial)
|
|
require.Len(t, state.Resources, applies)
|
|
}
|
|
|
|
// TestConfigurationTransactionWrites runs every write apply makes inside one
|
|
// transaction: the transaction reads what it wrote, and the commit makes it
|
|
// visible through the store's cached reads.
|
|
func TestConfigurationTransactionWrites(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
t.Cleanup(func() { require.NoError(t, ts.Close()) })
|
|
|
|
// Prime the setting cache, so the test sees whether the commit invalidates it.
|
|
_, err := ts.GetInstanceGeneralSetting(ctx)
|
|
require.NoError(t, err)
|
|
existing, err := ts.CreateUser(ctx, &store.User{Username: "existing", Role: store.RoleAdmin, PasswordHash: "hash"})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.RunConfigurationTransaction(ctx, func(ctx context.Context, tx *store.ConfigurationTransaction) (*storepb.InstanceConfigurationState, error) {
|
|
require.NoError(t, tx.CreateIdentityProvider(ctx, createTestOAuth2IDP("SSO", "sso")))
|
|
providers, err := tx.ListIdentityProviders(ctx, &store.FindIdentityProvider{})
|
|
require.NoError(t, err)
|
|
require.Len(t, providers, 1, "the transaction reads its own write")
|
|
replaced := proto.CloneOf(providers[0])
|
|
replaced.Name = "Renamed SSO"
|
|
replaced.Config.GetOauth2Config().Scopes = []string{"openid"}
|
|
require.NoError(t, tx.ReplaceIdentityProvider(ctx, providers[0].Id, replaced))
|
|
|
|
require.NoError(t, tx.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{Key: storepb.InstanceSettingKey_GENERAL, Value: &storepb.InstanceSetting_GeneralSetting{
|
|
GeneralSetting: &storepb.InstanceGeneralSetting{CustomProfile: &storepb.InstanceCustomProfile{Title: "Configured"}},
|
|
}}))
|
|
general, err := tx.GetUncachedInstanceSetting(ctx, &store.FindInstanceSetting{Name: "GENERAL"})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "Configured", general.GetGeneralSetting().GetCustomProfile().GetTitle())
|
|
require.NoError(t, tx.DeleteInstanceSetting(ctx, storepb.InstanceSettingKey_NOTIFICATION))
|
|
|
|
created, err := tx.CreateUser(ctx, &store.User{Username: "admin", Role: store.RoleAdmin, Email: " Admin@Example.com ", PasswordHash: "hash"})
|
|
require.NoError(t, err)
|
|
role := store.RoleUser
|
|
nickname := "Demoted"
|
|
require.NoError(t, tx.UpdateUser(ctx, &store.UpdateUser{ID: existing.ID, Role: &role, Nickname: &nickname}))
|
|
users, err := tx.ListUsers(ctx, &store.FindUser{UsernameList: []string{"admin", "existing"}})
|
|
require.NoError(t, err)
|
|
require.Len(t, users, 2)
|
|
require.Equal(t, "admin@example.com", created.Email, "the email is normalized as the store's writes do")
|
|
return &storepb.InstanceConfigurationState{}, nil
|
|
})
|
|
require.NoError(t, err)
|
|
|
|
provider, err := ts.GetIdentityProvider(ctx, &store.FindIdentityProvider{UID: new("sso")})
|
|
require.NoError(t, err)
|
|
require.Equal(t, "Renamed SSO", provider.Name)
|
|
require.Equal(t, []string{"openid"}, provider.Config.GetOauth2Config().Scopes)
|
|
general, err := ts.GetInstanceGeneralSetting(ctx)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "Configured", general.GetCustomProfile().GetTitle(), "the commit invalidated the cached setting")
|
|
notification, err := ts.GetUncachedInstanceSetting(ctx, &store.FindInstanceSetting{Name: "NOTIFICATION"})
|
|
require.NoError(t, err)
|
|
require.Nil(t, notification)
|
|
demoted, err := ts.GetUser(ctx, &store.FindUser{ID: &existing.ID})
|
|
require.NoError(t, err)
|
|
require.Equal(t, store.RoleUser, demoted.Role)
|
|
require.Equal(t, "Demoted", demoted.Nickname, "the commit invalidated the cached user")
|
|
}
|
|
|
|
func TestConfigurationTransactionRollsBack(t *testing.T) {
|
|
t.Parallel()
|
|
ctx := context.Background()
|
|
ts := NewTestingStore(ctx, t)
|
|
t.Cleanup(func() { require.NoError(t, ts.Close()) })
|
|
only, err := ts.CreateUser(ctx, &store.User{Username: "only", Role: store.RoleAdmin, PasswordHash: "hash"})
|
|
require.NoError(t, err)
|
|
|
|
_, err = ts.RunConfigurationTransaction(ctx, func(ctx context.Context, tx *store.ConfigurationTransaction) (*storepb.InstanceConfigurationState, error) {
|
|
require.NoError(t, tx.CreateIdentityProvider(ctx, createTestOAuth2IDP("SSO", "sso")))
|
|
role := store.RoleUser
|
|
// Demoting the last administrator fails as it does through the API,
|
|
// and the whole transaction rolls back with it.
|
|
return nil, tx.UpdateUser(ctx, &store.UpdateUser{ID: only.ID, Role: &role})
|
|
})
|
|
require.ErrorIs(t, err, store.ErrLastInstanceAdmin)
|
|
|
|
providers, err := ts.ListIdentityProviders(ctx, &store.FindIdentityProvider{})
|
|
require.NoError(t, err)
|
|
require.Empty(t, providers, "nothing from the failed transaction remains")
|
|
state, err := ts.GetConfigurationState(ctx)
|
|
require.NoError(t, err)
|
|
require.Zero(t, state.Serial)
|
|
}
|