Files
memos/core/configuration/plan_test.go
T
johnnyjoygh 5f3969a830 feat(reactions): add full emoji picker
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.
2026-11-14 20:46:46 +08:00

522 lines
27 KiB
Go

package configuration
import (
"bytes"
"context"
"slices"
"strings"
"testing"
"github.com/stretchr/testify/require"
"google.golang.org/protobuf/encoding/protojson"
"google.golang.org/protobuf/proto"
"google.golang.org/protobuf/reflect/protoregistry"
"github.com/usememos/memos/core/identityprovider"
"github.com/usememos/memos/core/instancesetting"
apipb "github.com/usememos/memos/proto/gen/api"
storepb "github.com/usememos/memos/proto/gen/store"
"github.com/usememos/memos/store"
)
// fakeReader is an in-memory instance for planning.
type fakeReader struct {
state *storepb.InstanceConfigurationState
providers []*storepb.IdentityProvider
settings map[storepb.InstanceSettingKey]*storepb.InstanceSetting
users []*store.User
identities []*store.UserIdentity
}
func newFakeReader() *fakeReader {
return &fakeReader{state: &storepb.InstanceConfigurationState{}, settings: map[storepb.InstanceSettingKey]*storepb.InstanceSetting{}}
}
func (f *fakeReader) GetConfigurationState(context.Context) (*storepb.InstanceConfigurationState, error) {
return proto.CloneOf(f.state), nil
}
func (f *fakeReader) ListIdentityProviders(context.Context, *store.FindIdentityProvider) ([]*storepb.IdentityProvider, error) {
result := []*storepb.IdentityProvider{}
for _, provider := range f.providers {
result = append(result, proto.CloneOf(provider))
}
return result, nil
}
func (f *fakeReader) GetUncachedInstanceSetting(_ context.Context, find *store.FindInstanceSetting) (*storepb.InstanceSetting, error) {
setting := f.settings[storepb.InstanceSettingKey(storepb.InstanceSettingKey_value[find.Name])]
if setting == nil {
return nil, nil
}
return proto.CloneOf(setting), nil
}
func (f *fakeReader) ListUsers(_ context.Context, find *store.FindUser) ([]*store.User, error) {
result := []*store.User{}
for _, user := range f.users {
if find.ID != nil && user.ID != *find.ID ||
find.Username != nil && user.Username != *find.Username ||
len(find.UsernameList) > 0 && !slices.Contains(find.UsernameList, user.Username) ||
len(find.IDList) > 0 && !slices.Contains(find.IDList, user.ID) {
continue
}
copied := *user
result = append(result, &copied)
}
return result, nil
}
func (f *fakeReader) ListUserIdentities(_ context.Context, find *store.FindUserIdentity) ([]*store.UserIdentity, error) {
result := []*store.UserIdentity{}
for _, identity := range f.identities {
if find.UserID != nil && identity.UserID != *find.UserID ||
find.Provider != nil && identity.Provider != *find.Provider ||
find.ExternUID != nil && identity.ExternUID != *find.ExternUID {
continue
}
copied := *identity
result = append(result, &copied)
}
return result, nil
}
// apply stands in for apply: the instance takes the declared values and the
// state record becomes the plan's.
func (f *fakeReader) apply(t *testing.T, desired *Desired, plan *Plan) {
t.Helper()
require.True(t, plan.Valid(), plan.Message.Errors)
f.providers = nil
for i, provider := range desired.Configuration.IdentityProviders {
stored := identityprovider.ToStore(provider)
stored.Id = int32(i + 1)
f.providers = append(f.providers, stored)
}
for _, setting := range desired.Configuration.InstanceSettings {
stored := instancesetting.ToStore(setting)
instancesetting.Normalize(stored)
f.settings[stored.Key] = stored
}
next := proto.CloneOf(plan.next)
next.Serial = f.state.Serial + 1
f.state = next
}
func loadDesired(t *testing.T, files map[string]string) *Desired {
t.Helper()
desired, err := Load(writeFiles(t, files), placeholderResolver())
require.NoError(t, err)
return desired
}
func planFor(t *testing.T, desired *Desired, reader Reader) *Plan {
t.Helper()
result, err := ComputePlan(context.Background(), desired, reader)
require.NoError(t, err)
return result
}
func changeFor(t *testing.T, plan *Plan, resource string) *apipb.ResourceChange {
t.Helper()
for _, change := range plan.Message.ResourceChanges {
if change.Resource == resource {
return change
}
}
require.Failf(t, "no change", "plan has no change for %s", resource)
return nil
}
func generalSetting(title string) *storepb.InstanceSetting {
return &storepb.InstanceSetting{Key: storepb.InstanceSettingKey_GENERAL, Value: &storepb.InstanceSetting_GeneralSetting{
GeneralSetting: &storepb.InstanceGeneralSetting{CustomProfile: &storepb.InstanceCustomProfile{Title: title}},
}}
}
func generalDocument(title string) string {
return `{"instanceSettings":[{"name":"instance/settings/GENERAL","generalSetting":{"customProfile":{"title":"` + title + `"}}}]}`
}
func TestPlanCreateAdoptNoOpAndDrift(t *testing.T) {
reader := newFakeReader()
reader.settings[storepb.InstanceSettingKey_GENERAL] = generalSetting("memos")
desired := loadDesired(t, map[string]string{"idp.json": `{"identityProviders":[` + validIDP + `]}`, "general.json": generalDocument("Company")})
first := planFor(t, desired, reader)
require.True(t, first.Valid())
require.True(t, first.HasChanges())
require.Equal(t, apipb.ResourceChange_CREATE, changeFor(t, first, "identity-providers/sso").Action)
general := changeFor(t, first, "instance/settings/GENERAL")
require.Equal(t, apipb.ResourceChange_ADOPT, general.Action)
require.Equal(t, "general.json", general.Source)
require.Equal(t, []*apipb.FieldChange{{Path: "generalSetting.customProfile.title", Before: `"memos"`, After: `"Company"`}}, general.FieldChanges)
reader.apply(t, desired, first)
second := planFor(t, desired, reader)
require.False(t, second.HasChanges(), "a second plan after apply is empty")
for _, change := range second.Message.ResourceChanges {
require.Equal(t, apipb.ResourceChange_NO_OP, change.Action, change.Resource)
}
// An edit outside the configuration is drift.
reader.settings[storepb.InstanceSettingKey_GENERAL] = generalSetting("Edited in the UI")
drifted := changeFor(t, planFor(t, desired, reader), "instance/settings/GENERAL")
require.Equal(t, apipb.ResourceChange_UPDATE, drifted.Action)
require.True(t, drifted.Drift)
// A changed file is an update, not drift.
changed := loadDesired(t, map[string]string{"idp.json": `{"identityProviders":[` + validIDP + `]}`, "general.json": generalDocument("Renamed")})
updated := changeFor(t, planFor(t, changed, reader), "instance/settings/GENERAL")
require.Equal(t, apipb.ResourceChange_UPDATE, updated.Action)
require.False(t, updated.Drift)
// A managed resource deleted outside the configuration is recreated, as drift.
reader.providers = nil
recreated := changeFor(t, planFor(t, desired, reader), "identity-providers/sso")
require.Equal(t, apipb.ResourceChange_CREATE, recreated.Action)
require.True(t, recreated.Drift)
}
func TestPlanComparesNormalizedValues(t *testing.T) {
reader := newFakeReader()
reader.settings[storepb.InstanceSettingKey_AI] = &storepb.InstanceSetting{Key: storepb.InstanceSettingKey_AI, Value: &storepb.InstanceSetting_AiSetting{
AiSetting: &storepb.InstanceAISetting{Providers: []*storepb.AIProviderConfig{
{Id: "openai", Title: "OpenAI", Type: storepb.AIProviderType_OPENAI, Endpoint: instancesetting.DefaultOpenAIEndpoint, ApiKey: "placeholder"},
}},
}}
storage := &storepb.InstanceStorageSetting{StorageType: storepb.InstanceStorageSetting_LOCAL}
store.NormalizeInstanceStorageSetting(storage)
reader.settings[storepb.InstanceSettingKey_STORAGE] = &storepb.InstanceSetting{Key: storepb.InstanceSettingKey_STORAGE, Value: &storepb.InstanceSetting_StorageSetting{StorageSetting: storage}}
desired := loadDesired(t, map[string]string{"settings.json": `{"instanceSettings":[
{"name":"instance/settings/AI","aiSetting":{"providers":[{"id":"openai","title":"OpenAI","type":"OPENAI","apiKey":"${env:KEY}"}]}},
{"name":"instance/settings/STORAGE","storageSetting":{"storageType":"LOCAL"}}
]}`})
for _, change := range planFor(t, desired, reader).Message.ResourceChanges {
require.Equal(t, apipb.ResourceChange_ADOPT, change.Action, change.Resource)
require.Empty(t, change.FieldChanges, "a default endpoint and a normalized storage registry are not differences: %s", change.Resource)
}
}
func TestPlanNeverPrintsSecrets(t *testing.T) {
reader := newFakeReader()
stored := identityprovider.ToStore(loadDesired(t, map[string]string{"idp.json": `{"identityProviders":[` + validIDP + `]}`}).Configuration.IdentityProviders[0])
stored.Config.GetOauth2Config().ClientSecret = "old-client-secret"
reader.providers = []*storepb.IdentityProvider{stored}
withSecret := strings.Replace(validIDP, `"clientId":"memos",`, `"clientId":"memos","clientSecret":"new-client-secret",`, 1)
result := planFor(t, loadDesired(t, map[string]string{"idp.json": `{"identityProviders":[` + withSecret + `]}`}), reader)
change := changeFor(t, result, "identity-providers/sso")
require.Equal(t, []*apipb.FieldChange{{Path: "config.oauth2Config.clientSecret", Before: "(sensitive)", After: "(sensitive)"}}, change.FieldChanges)
var text bytes.Buffer
RenderPlan(&text, result.Message)
encoded, err := protojson.Marshal(result.Message)
require.NoError(t, err)
for _, output := range []string{text.String(), string(encoded), result.next.String()} {
require.NotContains(t, output, "old-client-secret")
require.NotContains(t, output, "new-client-secret")
}
}
func TestPlanIgnoreChanges(t *testing.T) {
reader := newFakeReader()
reader.settings[storepb.InstanceSettingKey_GENERAL] = generalSetting("Edited in the UI")
desired := loadDesired(t, map[string]string{"general.json": `{"instanceSettings":[{"name":"instance/settings/GENERAL","generalSetting":{"customProfile":{"title":"Company"}}}],
"lifecycle":[{"resource":"instance/settings/GENERAL","ignoreChanges":["generalSetting.customProfile"]}]}`})
result := planFor(t, desired, reader)
change := changeFor(t, result, "instance/settings/GENERAL")
require.Empty(t, change.FieldChanges)
require.Equal(t, []string{"generalSetting.customProfile"}, result.next.Resources[0].IgnoredFields)
require.Equal(t, []string{"*"}, result.next.Resources[0].ManagedFields)
}
func TestPlanUndeclaredManagedResources(t *testing.T) {
reader := newFakeReader()
managed := func(name, kind string) *storepb.InstanceConfigurationState_ManagedResource {
return &storepb.InstanceConfigurationState_ManagedResource{Name: name, Kind: kind, ManagedFields: []string{"*"}}
}
locked := managed("identity-providers/locked", "IdentityProvider")
locked.PreventDestroy = true
reader.state = &storepb.InstanceConfigurationState{Serial: 4, Resources: []*storepb.InstanceConfigurationState_ManagedResource{
managed("identity-providers/destroyed", "IdentityProvider"),
managed("identity-providers/vanished", "IdentityProvider"),
locked,
managed("identity-providers/forgotten", "IdentityProvider"),
managed("instance/settings/NOTIFICATION", "InstanceSetting"),
managed("users/old", "User"),
managed("users/kept", "User"),
}}
reader.providers = []*storepb.IdentityProvider{{Id: 1, Uid: "destroyed"}, {Id: 2, Uid: "locked"}, {Id: 3, Uid: "forgotten"}}
reader.users = []*store.User{{ID: 1, Username: "old"}, {ID: 2, Username: "kept"}}
desired := loadDesired(t, map[string]string{"removed.json": `{"removed":[
{"resource":"identity-providers/destroyed","destroy":true},
{"resource":"identity-providers/vanished","destroy":true},
{"resource":"identity-providers/locked","destroy":true},
{"resource":"instance/settings/NOTIFICATION","destroy":true},
{"resource":"users/old","destroy":true},
{"resource":"users/kept"},
{"resource":"users/never-managed","destroy":true}
]}`})
result := planFor(t, desired, reader)
want := map[string]apipb.ResourceChange_Action{
"identity-providers/destroyed": apipb.ResourceChange_DESTROY,
"identity-providers/vanished": apipb.ResourceChange_RELEASE,
"identity-providers/locked": apipb.ResourceChange_ERROR,
"identity-providers/forgotten": apipb.ResourceChange_ERROR,
"instance/settings/NOTIFICATION": apipb.ResourceChange_RESET,
"users/old": apipb.ResourceChange_ERROR,
"users/kept": apipb.ResourceChange_RELEASE,
}
require.Len(t, result.Message.ResourceChanges, len(want), "a removed entry for a resource never managed is a no-op")
for resource, action := range want {
require.Equal(t, action, changeFor(t, result, resource).Action, resource)
}
require.False(t, result.Valid())
require.Len(t, result.Message.Errors, 3)
require.Contains(t, strings.Join(result.Message.Errors, "\n"), "users/old: configuration cannot delete a user")
require.Contains(t, strings.Join(result.Message.Errors, "\n"), "identity-providers/forgotten: managed but no longer declared")
require.Contains(t, strings.Join(result.Message.Errors, "\n"), "identity-providers/locked: preventDestroy was set")
require.Equal(t, int64(4), result.Message.Serial)
}
func TestPlanReleasesRetiredReactionSetting(t *testing.T) {
reader := newFakeReader()
reader.state = &storepb.InstanceConfigurationState{Resources: []*storepb.InstanceConfigurationState_ManagedResource{
{Name: "instance/settings/MEMO_RELATED", Kind: "InstanceSetting", ManagedFields: []string{"*"}},
}}
desired := loadDesired(t, map[string]string{"empty.json": `{}`})
plan := planFor(t, desired, reader)
require.True(t, plan.Valid())
require.Equal(t, apipb.ResourceChange_RELEASE, changeFor(t, plan, "instance/settings/MEMO_RELATED").Action)
require.Empty(t, plan.next.Resources)
}
func TestPlanOrdersActions(t *testing.T) {
reader := newFakeReader()
reader.state = &storepb.InstanceConfigurationState{Resources: []*storepb.InstanceConfigurationState_ManagedResource{
{Name: "identity-providers/old", Kind: "IdentityProvider"},
}}
reader.providers = []*storepb.IdentityProvider{{Id: 1, Uid: "old"}}
desired := loadDesired(t, map[string]string{"all.json": `{
"identityProviders":[` + validIDP + `],
"instanceSettings":[{"name":"instance/settings/ACCESS","accessSetting":{"accessMode":"INSTANCE_ACCESS_MODE_PRIVATE"}}],
"users":[{"name":"users/admin","username":"admin","role":"ADMIN","password":"secret"}],
"removed":[{"resource":"identity-providers/old","destroy":true}]
}`})
result := planFor(t, desired, reader)
require.True(t, result.Valid(), result.Message.Errors)
order := []string{}
for _, change := range result.Message.ResourceChanges {
order = append(order, change.Resource)
}
require.Equal(t, []string{"identity-providers/sso", "instance/settings/ACCESS", "users/admin", "identity-providers/old"}, order)
}
func TestPlanLinkedIdentities(t *testing.T) {
admin := func(identity string) map[string]string {
return map[string]string{"all.json": `{
"identityProviders":[` + validIDP + `],
"users":[{"name":"users/admin","username":"admin","role":"ADMIN","password":"pw"}],
"linkedIdentities":[` + identity + `]}`}
}
declared := admin(`{"name":"users/admin/linkedIdentities/sso","externalUid":"subject-1"}`)
// Everything new: the link is created after its user, and it names its provider.
reader := newFakeReader()
result := planFor(t, loadDesired(t, declared), reader)
require.True(t, result.Valid(), result.Message.Errors)
link := changeFor(t, result, "users/admin/linkedIdentities/sso")
require.Equal(t, apipb.ResourceChange_CREATE, link.Action)
require.Equal(t, []*apipb.FieldChange{{Path: "externalUid", After: `"subject-1"`}}, link.FieldChanges)
order := []string{}
for _, change := range result.Message.ResourceChanges {
order = append(order, change.Resource)
}
require.Equal(t, []string{"identity-providers/sso", "users/admin", "users/admin/linkedIdentities/sso"}, order)
for _, resource := range result.next.Resources {
if resource.Name == "users/admin/linkedIdentities/sso" {
require.Equal(t, "LinkedIdentity", resource.Kind)
require.Equal(t, []string{"identity-providers/sso"}, resource.References)
}
}
// A link the user made by signing in is adopted; a different subject is replaced.
reader.users = []*store.User{{ID: 1, Username: "admin", Role: store.RoleAdmin}, {ID: 2, Username: "other"}}
reader.identities = []*store.UserIdentity{{ID: 1, UserID: 1, Provider: "sso", ExternUID: "subject-1"}}
require.Equal(t, apipb.ResourceChange_ADOPT, changeFor(t, planFor(t, loadDesired(t, declared), reader), "users/admin/linkedIdentities/sso").Action)
replaced := changeFor(t, planFor(t, loadDesired(t, admin(`{"name":"users/admin/linkedIdentities/sso","externalUid":"subject-2"}`)), reader), "users/admin/linkedIdentities/sso")
require.Equal(t, apipb.ResourceChange_ADOPT, replaced.Action)
require.Equal(t, []*apipb.FieldChange{{Path: "externalUid", Before: `"subject-1"`, After: `"subject-2"`}}, replaced.FieldChanges)
// A subject another user holds is never taken over.
reader.identities = []*store.UserIdentity{{ID: 1, UserID: 2, Provider: "sso", ExternUID: "subject-1"}}
taken := planFor(t, loadDesired(t, declared), reader)
require.False(t, taken.Valid())
require.Contains(t, strings.Join(taken.Message.Errors, "\n"), "the identity-providers/sso subject is already linked to users/other; unlink it there first")
// The provider must exist after apply, declared or stored.
reader.identities = nil
missing := planFor(t, loadDesired(t, admin(`{"name":"users/admin/linkedIdentities/elsewhere","externalUid":"subject-1"}`)), reader)
require.Contains(t, strings.Join(missing.Message.Errors, "\n"), "names identity-providers/elsewhere, which would not exist after apply")
reader.providers = []*storepb.IdentityProvider{{Id: 2, Uid: "elsewhere"}}
require.True(t, planFor(t, loadDesired(t, admin(`{"name":"users/admin/linkedIdentities/elsewhere","externalUid":"subject-1"}`)), reader).Valid())
// Undeclared: destroy deletes the stored link, or releases one already gone.
reader.identities = []*store.UserIdentity{{ID: 1, UserID: 1, Provider: "sso", ExternUID: "subject-1"}}
reader.state = &storepb.InstanceConfigurationState{Resources: []*storepb.InstanceConfigurationState_ManagedResource{
{Name: "users/admin/linkedIdentities/sso", Kind: "LinkedIdentity", ManagedFields: []string{"*"}},
{Name: "users/admin/linkedIdentities/gone", Kind: "LinkedIdentity", ManagedFields: []string{"*"}},
{Name: "users/admin/linkedIdentities/kept", Kind: "LinkedIdentity", ManagedFields: []string{"*"}},
}}
removed := planFor(t, loadDesired(t, map[string]string{"removed.json": `{"removed":[
{"resource":"users/admin/linkedIdentities/sso","destroy":true},
{"resource":"users/admin/linkedIdentities/gone","destroy":true},
{"resource":"users/admin/linkedIdentities/kept"}]}`}), reader)
require.True(t, removed.Valid(), removed.Message.Errors)
require.Equal(t, apipb.ResourceChange_DESTROY, changeFor(t, removed, "users/admin/linkedIdentities/sso").Action)
require.Equal(t, apipb.ResourceChange_RELEASE, changeFor(t, removed, "users/admin/linkedIdentities/gone").Action)
require.Equal(t, apipb.ResourceChange_RELEASE, changeFor(t, removed, "users/admin/linkedIdentities/kept").Action)
}
func TestPlanUsers(t *testing.T) {
reader := newFakeReader()
require.Contains(t, strings.Join(planFor(t, loadDesired(t, map[string]string{"u.json": `{"users":[{"name":"users/admin","username":"admin","role":"ADMIN"}]}`}), reader).Message.Errors, ""),
"password is required to create the user")
created := changeFor(t, planFor(t, loadDesired(t, map[string]string{"u.json": `{"users":[{"name":"users/admin","username":"admin","role":"ADMIN","password":"pw"}]}`}), reader), "users/admin")
require.Equal(t, apipb.ResourceChange_CREATE, created.Action)
require.Equal(t, []*apipb.FieldChange{
{Path: "username", After: `"admin"`},
{Path: "role", After: "ADMIN"},
{Path: "password", After: "(write-only, version 0)"},
}, created.FieldChanges, "an undeclared displayName or email is not managed")
reader.users = []*store.User{{ID: 1, Username: "admin", Role: store.RoleAdmin, Nickname: "Set by the user", Email: "admin@example.com"}}
reader.state = &storepb.InstanceConfigurationState{Resources: []*storepb.InstanceConfigurationState_ManagedResource{
{Name: "users/admin", Kind: "User", ManagedFields: []string{"username", "role"}, WriteOnlyVersion: 1},
}}
user := func(extra, lifecycle string) *Desired {
return loadDesired(t, map[string]string{"u.json": `{"users":[{"name":"users/admin","username":"admin","role":"ADMIN","password":"pw"` + extra + `}]` + lifecycle + `}`})
}
untouched := planFor(t, user("", `,"lifecycle":[{"resource":"users/admin","writeOnlyVersion":1}]`), reader)
require.Equal(t, apipb.ResourceChange_NO_OP, changeFor(t, untouched, "users/admin").Action, "the profile and the password are left alone")
cleared := changeFor(t, planFor(t, user(`,"displayName":""`, `,"lifecycle":[{"resource":"users/admin","writeOnlyVersion":1}]`), reader), "users/admin")
require.Equal(t, []*apipb.FieldChange{{Path: "displayName", Before: `"Set by the user"`, After: `""`}}, cleared.FieldChanges,
"a declared empty displayName is managed")
bumped := planFor(t, user("", `,"lifecycle":[{"resource":"users/admin","writeOnlyVersion":2}]`), reader)
require.Equal(t, []*apipb.FieldChange{{Path: "password", Before: "(write-only)", After: "(write-only, version 2)"}}, changeFor(t, bumped, "users/admin").FieldChanges)
require.Equal(t, int32(2), bumped.next.Resources[0].WriteOnlyVersion)
noPassword := loadDesired(t, map[string]string{"u.json": `{"users":[{"name":"users/admin","username":"admin","role":"ADMIN"}],"lifecycle":[{"resource":"users/admin","writeOnlyVersion":2}]}`})
require.Contains(t, strings.Join(planFor(t, noPassword, reader).Message.Errors, ""), "no password is declared")
// A user with a declared linked identity needs no password to be created.
linked := planFor(t, loadDesired(t, map[string]string{"u.json": `{"identityProviders":[` + validIDP + `],
"users":[{"name":"users/sso-admin","username":"sso-admin","role":"ADMIN"}],
"linkedIdentities":[{"name":"users/sso-admin/linkedIdentities/sso","externalUid":"subject"}]}`}), newFakeReader())
require.True(t, linked.Valid(), linked.Message.Errors)
ssoAdmin := changeFor(t, linked, "users/sso-admin")
require.Equal(t, apipb.ResourceChange_CREATE, ssoAdmin.Action)
require.Equal(t, []*apipb.FieldChange{{Path: "username", After: `"sso-admin"`}, {Path: "role", After: "ADMIN"}}, ssoAdmin.FieldChanges)
require.Equal(t, "created without a password; signs in through its linked identity", ssoAdmin.Message)
}
func TestPlanAuthenticationInvariant(t *testing.T) {
disallow := `{"instanceSettings":[{"name":"instance/settings/GENERAL","generalSetting":{"disallowPasswordAuth":true}}]}`
reader := newFakeReader()
require.Contains(t, strings.Join(planFor(t, loadDesired(t, map[string]string{"g.json": disallow}), reader).Message.Errors, ""), "no identity provider would remain")
require.True(t, planFor(t, loadDesired(t, map[string]string{"g.json": disallow, "idp.json": `{"identityProviders":[` + validIDP + `]}`}), reader).Valid(),
"a declared provider satisfies it")
reader.settings[storepb.InstanceSettingKey_GENERAL] = &storepb.InstanceSetting{Key: storepb.InstanceSettingKey_GENERAL, Value: &storepb.InstanceSetting_GeneralSetting{
GeneralSetting: &storepb.InstanceGeneralSetting{DisallowPasswordAuth: true},
}}
reader.providers = []*storepb.IdentityProvider{{Id: 1, Uid: "last"}}
reader.state = &storepb.InstanceConfigurationState{Resources: []*storepb.InstanceConfigurationState_ManagedResource{{Name: "identity-providers/last", Kind: "IdentityProvider"}}}
destroyLast := planFor(t, loadDesired(t, map[string]string{"r.json": `{"removed":[{"resource":"identity-providers/last","destroy":true}]}`}), reader)
require.Contains(t, strings.Join(destroyLast.Message.Errors, ""), "no identity provider would remain")
reader.providers = nil
reader.state = &storepb.InstanceConfigurationState{}
unrelated := planFor(t, loadDesired(t, map[string]string{"a.json": `{"instanceSettings":[{"name":"instance/settings/ACCESS","accessSetting":{"accessMode":"INSTANCE_ACCESS_MODE_PRIVATE"}}]}`}), reader)
require.True(t, unrelated.Valid(), "an unrelated plan does not fail on an existing condition")
require.Contains(t, strings.Join(unrelated.Message.Warnings, ""), "already has")
}
func TestPlanUsageLimitsResolveUsers(t *testing.T) {
reader := newFakeReader()
reader.users = []*store.User{{ID: 7, Username: "alice"}}
reader.settings[storepb.InstanceSettingKey_USAGE_LIMITS] = &storepb.InstanceSetting{Key: storepb.InstanceSettingKey_USAGE_LIMITS, Value: &storepb.InstanceSetting_UsageLimitsSetting{
UsageLimitsSetting: &storepb.InstanceUsageLimitsSetting{Limits: []*storepb.InstanceUsageLimitsSetting_UsageLimit{
{UserIds: []int32{7}, MemoCount: new(int64(10))},
{AllUsers: true},
}},
}}
limits := func(users string) *Desired {
return loadDesired(t, map[string]string{"l.json": `{"instanceSettings":[{"name":"instance/settings/USAGE_LIMITS","usageLimitsSetting":{"limits":[
{"users":[` + users + `],"memoCount":"10"},{"allUsers":true}]}}]}`})
}
change := changeFor(t, planFor(t, limits(`"users/alice"`), reader), "instance/settings/USAGE_LIMITS")
require.Empty(t, change.FieldChanges, "user names resolve to the stored IDs")
missing := planFor(t, limits(`"users/carol"`), reader)
require.Contains(t, strings.Join(missing.Message.Errors, ""), "names users/carol, which does not exist")
}
func TestPlanStateOnlyChange(t *testing.T) {
reader := newFakeReader()
reader.settings[storepb.InstanceSettingKey_GENERAL] = generalSetting("Company")
desired := loadDesired(t, map[string]string{"general.json": generalDocument("Company")})
reader.apply(t, desired, planFor(t, desired, reader))
locked := loadDesired(t, map[string]string{"general.json": `{"instanceSettings":[{"name":"instance/settings/GENERAL","generalSetting":{"customProfile":{"title":"Company"}}}],
"lifecycle":[{"resource":"instance/settings/GENERAL","preventDestroy":true}]}`})
result := planFor(t, locked, reader)
require.Equal(t, apipb.ResourceChange_NO_OP, changeFor(t, result, "instance/settings/GENERAL").Action)
require.True(t, result.HasChanges(), "the state record now records preventDestroy")
var text bytes.Buffer
RenderPlan(&text, result.Message)
require.Equal(t, "No resource changes. Apply would only update the state record.\n", text.String())
}
func TestRenderPlan(t *testing.T) {
var text bytes.Buffer
RenderPlan(&text, &apipb.Plan{ResourceChanges: []*apipb.ResourceChange{
{Resource: "identity-providers/company-sso", Source: "instance.json", Action: apipb.ResourceChange_CREATE},
{Resource: "instance/settings/GENERAL", Source: "instance.json", Action: apipb.ResourceChange_ADOPT, FieldChanges: []*apipb.FieldChange{
{Path: "generalSetting.disallowPasswordAuth", Before: "false", After: "true"},
{Path: "generalSetting.customProfile.title", Before: `"memos"`, After: `"Company Memos"`},
}},
{Resource: "instance/settings/ACCESS", Source: "instance.json", Action: apipb.ResourceChange_NO_OP},
{Resource: "users/admin", Source: "instance.json", Action: apipb.ResourceChange_UPDATE, Drift: true, FieldChanges: []*apipb.FieldChange{
{Path: "role", Before: "USER", After: "ADMIN"},
}},
}, StateRecordChanges: true})
require.Equal(t, `Plan: 1 to create, 1 to update, 0 to destroy; 1 to adopt.
+ identity-providers/company-sso (instance.json)
~ instance/settings/GENERAL (instance.json) adopt
generalSetting.disallowPasswordAuth: false -> true
generalSetting.customProfile.title: "memos" -> "Company Memos"
~ users/admin (instance.json) drift
role: USER -> ADMIN
`, text.String())
text.Reset()
RenderPlan(&text, &apipb.Plan{ResourceChanges: []*apipb.ResourceChange{{Resource: "instance/settings/ACCESS", Action: apipb.ResourceChange_NO_OP}}})
require.Equal(t, "No changes. The instance matches the configuration.\n", text.String())
}
func TestSensitiveFieldsExist(t *testing.T) {
for _, name := range sensitiveFields {
_, err := protoregistry.GlobalFiles.FindDescriptorByName(name)
require.NoError(t, err, "%s was renamed; update sensitiveFields", name)
}
}