Skip to content

armgit / memos

Public Imported from GitHub
0

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.

41.1 KB
Raw Blame
package test

import (
	"context"
	"strings"
	"testing"

	"github.com/stretchr/testify/require"
	colorpb "google.golang.org/genproto/googleapis/type/color"
	"google.golang.org/grpc/codes"
	"google.golang.org/grpc/status"
	"google.golang.org/protobuf/types/known/fieldmaskpb"

	apipb "github.com/usememos/memos/proto/gen/api"
	storepb "github.com/usememos/memos/proto/gen/store"
	"github.com/usememos/memos/store"
)

func TestGetInstanceProfile(t *testing.T) {
	ctx := context.Background()

	t.Run("GetInstanceProfile returns instance profile", func(t *testing.T) {
		// Create test service for this specific test
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Call GetInstanceProfile directly
		req := &apipb.GetInstanceProfileRequest{}
		resp, err := ts.Service.GetInstanceProfile(ctx, req)

		// Verify response
		require.NoError(t, err)
		require.NotNil(t, resp)

		// Verify the response contains expected data
		require.Equal(t, "test-1.0.0", resp.Version)
		require.Equal(t, "test-commit", resp.Commit)
		require.True(t, resp.Demo)
		require.Equal(t, "http://localhost:8080", resp.InstanceUrl)
		require.Equal(t, apipb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC, resp.AccessMode)

		// Instance should not be initialized since no users exist at all.
		require.Nil(t, resp.Admin)
		require.True(t, resp.NeedsSetup)
	})

	t.Run("GetInstanceProfile with initialized instance", func(t *testing.T) {
		// Create test service for this specific test
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create a host user in the store
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		require.NotNil(t, hostUser)

		// Call GetInstanceProfile as the signed-in admin
		req := &apipb.GetInstanceProfileRequest{}
		resp, err := ts.Service.GetInstanceProfile(ts.CreateUserContext(ctx, hostUser.ID), req)

		// Verify response
		require.NoError(t, err)
		require.NotNil(t, resp)

		// Verify the response contains expected data with initialized flag
		require.Equal(t, "test-1.0.0", resp.Version)
		require.Equal(t, "test-commit", resp.Commit)
		require.True(t, resp.Demo)
		require.Equal(t, "http://localhost:8080", resp.InstanceUrl)

		// Instance should be initialized since an admin user exists
		require.NotNil(t, resp.Admin)
		require.Equal(t, hostUser.Username, resp.Admin.Username)
		require.False(t, resp.NeedsSetup)
	})

	t.Run("GetInstanceProfile hides the admin from anonymous callers", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		// The endpoint is public so the sign-in page can render, but an
		// unauthenticated visitor must not learn the admin's username.
		resp, err := ts.Service.GetInstanceProfile(ctx, &apipb.GetInstanceProfileRequest{})
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Nil(t, resp.Admin)
		require.False(t, resp.NeedsSetup)

		// Any signed-in user, not only the admin, may see it.
		regularUser, err := ts.CreateRegularUser(ctx, "alice")
		require.NoError(t, err)
		resp, err = ts.Service.GetInstanceProfile(ts.CreateUserContext(ctx, regularUser.ID), &apipb.GetInstanceProfileRequest{})
		require.NoError(t, err)
		require.NotNil(t, resp.Admin)
		require.Equal(t, hostUser.Username, resp.Admin.Username)
	})

	t.Run("GetInstanceProfile with users but no admin", func(t *testing.T) {
		// Create test service for this specific test
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create a regular user but no admin. This mirrors an instance that has
		// lost all of its admins: admin is nil, but the instance is NOT a fresh
		// install and must not be flagged for first-run setup.
		regularUser, err := ts.CreateRegularUser(ctx, "alice")
		require.NoError(t, err)
		require.NotNil(t, regularUser)

		req := &apipb.GetInstanceProfileRequest{}
		resp, err := ts.Service.GetInstanceProfile(ts.CreateUserContext(ctx, regularUser.ID), req)
		require.NoError(t, err)
		require.NotNil(t, resp)

		// No admin to display, but setup is already done because a user exists.
		require.Nil(t, resp.Admin)
		require.False(t, resp.NeedsSetup)
	})
}

func TestGetInstanceProfile_Concurrency(t *testing.T) {
	ctx := context.Background()

	t.Run("Concurrent access to service", func(t *testing.T) {
		// Create test service for this specific test
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create a host user
		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		// Make concurrent requests
		numGoroutines := 10
		results := make(chan *apipb.InstanceProfile, numGoroutines)
		errors := make(chan error, numGoroutines)

		for range numGoroutines {
			go func() {
				req := &apipb.GetInstanceProfileRequest{}
				resp, err := ts.Service.GetInstanceProfile(userCtx, req)
				if err != nil {
					errors <- err
					return
				}
				results <- resp
			}()
		}

		// Collect all results
		for range numGoroutines {
			select {
			case err := <-errors:
				t.Fatalf("Goroutine returned error: %v", err)
			case resp := <-results:
				require.NotNil(t, resp)
				require.Equal(t, "test-1.0.0", resp.Version)
				require.Equal(t, "test-commit", resp.Commit)
				require.True(t, resp.Demo)
				require.Equal(t, "http://localhost:8080", resp.InstanceUrl)
				require.NotNil(t, resp.Admin)
			}
		}
	})
}

func TestGetInstanceSetting(t *testing.T) {
	ctx := context.Background()

	t.Run("GetInstanceSetting - general setting", func(t *testing.T) {
		// Create test service for this specific test
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Call GetInstanceSetting for general setting
		req := &apipb.GetInstanceSettingRequest{
			Name: "instance/settings/GENERAL",
		}
		resp, err := ts.Service.GetInstanceSetting(ctx, req)

		// Verify response
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Equal(t, "instance/settings/GENERAL", resp.Name)

		// The general setting should have a general_setting field
		generalSetting := resp.GetGeneralSetting()
		require.NotNil(t, generalSetting)

		// General setting should have default values
		require.False(t, generalSetting.DisallowUserRegistration)
		require.False(t, generalSetting.DisallowPasswordAuth)
		require.Empty(t, generalSetting.AdditionalScript)
	})

	t.Run("GetInstanceSetting - storage setting", func(t *testing.T) {
		// Create test service for this specific test
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Create a host user for storage setting access
		hostUser, err := ts.CreateHostUser(ctx, "testhost")
		require.NoError(t, err)

		// Add user to context
		userCtx := ts.CreateUserContext(ctx, hostUser.ID)

		// Call GetInstanceSetting for storage setting
		req := &apipb.GetInstanceSettingRequest{
			Name: "instance/settings/STORAGE",
		}
		resp, err := ts.Service.GetInstanceSetting(userCtx, req)

		// Verify response
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Equal(t, "instance/settings/STORAGE", resp.Name)

		// The storage setting should have a storage_setting field
		storageSetting := resp.GetStorageSetting()
		require.NotNil(t, storageSetting)
	})

	t.Run("GetInstanceSetting - memo related setting", func(t *testing.T) {
		// Create test service for this specific test
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Call GetInstanceSetting for memo related setting
		req := &apipb.GetInstanceSettingRequest{
			Name: "instance/settings/MEMO_RELATED",
		}
		resp, err := ts.Service.GetInstanceSetting(ctx, req)

		// Verify response
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Equal(t, "instance/settings/MEMO_RELATED", resp.Name)

		// The memo related setting should have a memo_related_setting field
		memoRelatedSetting := resp.GetMemoRelatedSetting()
		require.NotNil(t, memoRelatedSetting)
	})

	t.Run("GetInstanceSetting - tags setting", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		req := &apipb.GetInstanceSettingRequest{
			Name: "instance/settings/TAGS",
		}
		resp, err := ts.Service.GetInstanceSetting(ctx, req)

		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Equal(t, "instance/settings/TAGS", resp.Name)
		require.NotNil(t, resp.GetTagsSetting())
		require.Empty(t, resp.GetTagsSetting().GetTags())
	})

	t.Run("GetInstanceSetting - access setting", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		resp, err := ts.Service.GetInstanceSetting(ctx, &apipb.GetInstanceSettingRequest{
			Name: "instance/settings/ACCESS",
		})

		require.NoError(t, err)
		require.Equal(t, "instance/settings/ACCESS", resp.Name)
		require.Equal(t, apipb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC, resp.GetAccessSetting().GetAccessMode())
	})

	t.Run("GetInstanceSetting - notification setting requires admin", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		admin, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, admin.ID)

		regularUser, err := ts.CreateRegularUser(ctx, "user")
		require.NoError(t, err)
		userCtx := ts.CreateUserContext(ctx, regularUser.ID)

		req := &apipb.GetInstanceSettingRequest{Name: "instance/settings/NOTIFICATION"}

		// Unauthenticated request must be rejected.
		_, err = ts.Service.GetInstanceSetting(ctx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "not authenticated")

		// Non-admin request must be rejected.
		_, err = ts.Service.GetInstanceSetting(userCtx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "permission denied")

		// Admin request succeeds and does NOT expose SmtpPassword.
		resp, err := ts.Service.GetInstanceSetting(adminCtx, req)
		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Equal(t, "instance/settings/NOTIFICATION", resp.Name)
		require.NotNil(t, resp.GetNotificationSetting())
		require.Empty(t, resp.GetNotificationSetting().GetEmail().GetSmtpPassword(),
			"SmtpPassword must never be returned in responses")
	})

	t.Run("GetInstanceSetting - AI setting requires authenticated user", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		admin, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, admin.ID)

		regularUser, err := ts.CreateRegularUser(ctx, "user")
		require.NoError(t, err)
		userCtx := ts.CreateUserContext(ctx, regularUser.ID)

		req := &apipb.GetInstanceSettingRequest{Name: "instance/settings/AI"}

		_, err = ts.Service.GetInstanceSetting(ctx, req)
		require.Error(t, err)
		require.Contains(t, err.Error(), "not authenticated")

		resp, err := ts.Service.GetInstanceSetting(userCtx, req)
		require.NoError(t, err)
		require.NotNil(t, resp.GetAiSetting())
		require.Empty(t, resp.GetAiSetting().GetProviders())

		resp, err = ts.Service.GetInstanceSetting(adminCtx, req)
		require.NoError(t, err)
		require.NotNil(t, resp.GetAiSetting())
		require.Empty(t, resp.GetAiSetting().GetProviders())
	})

	t.Run("GetInstanceSetting - invalid setting name", func(t *testing.T) {
		// Create test service for this specific test
		ts := NewTestService(t)
		defer ts.Cleanup()

		// Call GetInstanceSetting with invalid name
		req := &apipb.GetInstanceSettingRequest{
			Name: "invalid/setting/name",
		}
		_, err := ts.Service.GetInstanceSetting(ctx, req)

		// Should return an error
		require.Error(t, err)
		require.Contains(t, err.Error(), "invalid instance setting name")
	})
}

func TestBatchGetInstanceSettings(t *testing.T) {
	ctx := context.Background()

	t.Run("BatchGetInstanceSettings - returns settings in request order", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		resp, err := ts.Service.BatchGetInstanceSettings(ctx, &apipb.BatchGetInstanceSettingsRequest{
			Names: []string{
				"instance/settings/TAGS",
				"instance/settings/GENERAL",
				"instance/settings/MEMO_RELATED",
			},
		})

		require.NoError(t, err)
		require.NotNil(t, resp)
		require.Len(t, resp.InstanceSettings, 3)
		require.Equal(t, "instance/settings/TAGS", resp.InstanceSettings[0].Name)
		require.NotNil(t, resp.InstanceSettings[0].GetTagsSetting())
		require.Equal(t, "instance/settings/GENERAL", resp.InstanceSettings[1].Name)
		require.NotNil(t, resp.InstanceSettings[1].GetGeneralSetting())
		require.Equal(t, "instance/settings/MEMO_RELATED", resp.InstanceSettings[2].Name)
		require.NotNil(t, resp.InstanceSettings[2].GetMemoRelatedSetting())
	})

	t.Run("BatchGetInstanceSettings - admin-only setting requires admin", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		regularUser, err := ts.CreateRegularUser(ctx, "batch-user")
		require.NoError(t, err)
		userCtx := ts.CreateUserContext(ctx, regularUser.ID)

		_, err = ts.Service.BatchGetInstanceSettings(userCtx, &apipb.BatchGetInstanceSettingsRequest{
			Names: []string{"instance/settings/GENERAL", "instance/settings/NOTIFICATION"},
		})
		require.Error(t, err)
		require.Contains(t, err.Error(), "permission denied")

		admin, err := ts.CreateHostUser(ctx, "batch-admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, admin.ID)

		resp, err := ts.Service.BatchGetInstanceSettings(adminCtx, &apipb.BatchGetInstanceSettingsRequest{
			Names: []string{"instance/settings/GENERAL", "instance/settings/NOTIFICATION"},
		})
		require.NoError(t, err)
		require.Len(t, resp.InstanceSettings, 2)
		require.NotNil(t, resp.InstanceSettings[1].GetNotificationSetting())
	})

	t.Run("BatchGetInstanceSettings - invalid setting name", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		_, err := ts.Service.BatchGetInstanceSettings(ctx, &apipb.BatchGetInstanceSettingsRequest{
			Names: []string{"instance/settings/GENERAL", "invalid/setting/name"},
		})

		require.Error(t, err)
		require.Contains(t, err.Error(), "invalid instance setting name")
	})
}

func TestTestInstanceEmailSettingAuthorization(t *testing.T) {
	ctx := context.Background()
	ts := NewTestService(t)
	defer ts.Cleanup()

	admin, err := ts.CreateHostUser(ctx, "email-test-admin")
	require.NoError(t, err)
	adminCtx := ts.CreateUserContext(ctx, admin.ID)

	regularUser, err := ts.CreateRegularUser(ctx, "email-test-user")
	require.NoError(t, err)
	userCtx := ts.CreateUserContext(ctx, regularUser.ID)

	req := &apipb.TestInstanceEmailSettingRequest{}

	_, err = ts.Service.TestInstanceEmailSetting(ctx, req)
	require.Error(t, err)
	require.Contains(t, err.Error(), "not authenticated")

	_, err = ts.Service.TestInstanceEmailSetting(userCtx, req)
	require.Error(t, err)
	require.Contains(t, err.Error(), "permission denied")

	_, err = ts.Service.TestInstanceEmailSetting(adminCtx, req)
	require.Error(t, err)
	require.Contains(t, err.Error(), "invalid notification email setting")
}

func TestTestInstanceEmailSettingRequiresPasswordWhenSMTPIdentityChanges(t *testing.T) {
	ctx := context.Background()
	ts := NewTestService(t)
	defer ts.Cleanup()

	admin, err := ts.CreateHostUser(ctx, "email-test-identity-admin")
	require.NoError(t, err)
	adminCtx := ts.CreateUserContext(ctx, admin.ID)

	_, err = ts.Store.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{
		Key: storepb.InstanceSettingKey_NOTIFICATION,
		Value: &storepb.InstanceSetting_NotificationSetting{
			NotificationSetting: &storepb.InstanceNotificationSetting{
				Email: &storepb.InstanceNotificationSetting_EmailSetting{
					Enabled:      true,
					SmtpHost:     "smtp.example.com",
					SmtpPort:     587,
					SmtpUsername: "[email protected]",
					SmtpPassword: "stored-password",
					FromEmail:    "[email protected]",
					UseTls:       true,
				},
			},
		},
	})
	require.NoError(t, err)

	_, err = ts.Service.TestInstanceEmailSetting(adminCtx, &apipb.TestInstanceEmailSettingRequest{
		Email: &apipb.InstanceSetting_NotificationSetting_EmailSetting{
			Enabled:      true,
			SmtpHost:     "attacker.example.com",
			SmtpPort:     587,
			SmtpUsername: "[email protected]",
			SmtpPassword: "",
			FromEmail:    "[email protected]",
			UseTls:       true,
		},
		RecipientEmail: admin.Email,
	})
	require.Error(t, err)
	require.Contains(t, err.Error(), "smtp password is required")
}

func TestUpdateInstanceSetting(t *testing.T) {
	ctx := context.Background()

	t.Run("UpdateInstanceSetting - notification email validation", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		admin, err := ts.CreateHostUser(ctx, "notification-admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, admin.ID)
		update := func(email *apipb.InstanceSetting_NotificationSetting_EmailSetting) error {
			_, err := ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
				InstanceSetting: &apipb.InstanceSetting{
					Name: "instance/settings/NOTIFICATION",
					Value: &apipb.InstanceSetting_NotificationSetting_{
						NotificationSetting: &apipb.InstanceSetting_NotificationSetting{Email: email},
					},
				},
			})
			return err
		}
		valid := func() *apipb.InstanceSetting_NotificationSetting_EmailSetting {
			return &apipb.InstanceSetting_NotificationSetting_EmailSetting{
				Enabled:      true,
				SmtpHost:     "smtp.example.com",
				SmtpPort:     587,
				SmtpPassword: "password",
				FromEmail:    "[email protected]",
				UseTls:       true,
			}
		}

		bothEncryptions := valid()
		bothEncryptions.UseSsl = true
		err = update(bothEncryptions)
		require.Equal(t, codes.InvalidArgument, status.Code(err))
		require.Contains(t, err.Error(), "cannot enable both use_tls and use_ssl")

		for name, mutate := range map[string]func(*apipb.InstanceSetting_NotificationSetting_EmailSetting){
			"host": func(e *apipb.InstanceSetting_NotificationSetting_EmailSetting) { e.SmtpHost = " " },
			"port": func(e *apipb.InstanceSetting_NotificationSetting_EmailSetting) { e.SmtpPort = 0 },
			"from": func(e *apipb.InstanceSetting_NotificationSetting_EmailSetting) { e.FromEmail = "" },
		} {
			email := valid()
			mutate(email)
			err := update(email)
			require.Equal(t, codes.InvalidArgument, status.Code(err), "missing %s", name)
			require.Contains(t, err.Error(), "requires smtp_host", "missing %s", name)
		}

		require.NoError(t, update(valid()))
		// Disabled email may be saved incomplete.
		require.NoError(t, update(&apipb.InstanceSetting_NotificationSetting_EmailSetting{Enabled: false, SmtpPassword: "password"}))
	})

	t.Run("UpdateInstanceSetting - access setting", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		admin, err := ts.CreateHostUser(ctx, "access-admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, admin.ID)

		resp, err := ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/ACCESS",
				Value: &apipb.InstanceSetting_AccessSetting_{
					AccessSetting: &apipb.InstanceSetting_AccessSetting{
						AccessMode: apipb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE,
					},
				},
			},
		})
		require.NoError(t, err)
		require.Equal(t, apipb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE, resp.GetAccessSetting().GetAccessMode())

		profile, err := ts.Service.GetInstanceProfile(ctx, &apipb.GetInstanceProfileRequest{})
		require.NoError(t, err)
		require.Equal(t, apipb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE, profile.AccessMode)

		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/ACCESS",
				Value: &apipb.InstanceSetting_AccessSetting_{
					AccessSetting: &apipb.InstanceSetting_AccessSetting{},
				},
			},
		})
		require.Error(t, err)
		require.Contains(t, err.Error(), "access_mode must be PRIVATE or PUBLIC")

		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/ACCESS",
				Value: &apipb.InstanceSetting_GeneralSetting_{
					GeneralSetting: &apipb.InstanceSetting_GeneralSetting{},
				},
			},
		})
		require.Error(t, err)
		require.Contains(t, err.Error(), "access setting is required")
	})

	t.Run("UpdateInstanceSetting - AI setting requires admin", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		regularUser, err := ts.CreateRegularUser(ctx, "user")
		require.NoError(t, err)
		userCtx := ts.CreateUserContext(ctx, regularUser.ID)

		setting := &apipb.InstanceSetting{
			Name: "instance/settings/AI",
			Value: &apipb.InstanceSetting_AiSetting{
				AiSetting: &apipb.InstanceSetting_AISetting{
					Providers: []*apipb.InstanceSetting_AIProviderConfig{
						{
							Id:     "openai-main",
							Title:  "OpenAI",
							Type:   apipb.InstanceSetting_OPENAI,
							ApiKey: "sk-test",
						},
					},
				},
			},
		}

		_, err = ts.Service.UpdateInstanceSetting(ctx, &apipb.UpdateInstanceSettingRequest{InstanceSetting: setting})
		require.Error(t, err)
		require.Contains(t, err.Error(), "not authenticated")

		_, err = ts.Service.UpdateInstanceSetting(userCtx, &apipb.UpdateInstanceSettingRequest{InstanceSetting: setting})
		require.Error(t, err)
		require.Contains(t, err.Error(), "permission denied")
	})

	t.Run("UpdateInstanceSetting - tags setting", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		resp, err := ts.Service.UpdateInstanceSetting(ts.CreateUserContext(ctx, hostUser.ID), &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/TAGS",
				Value: &apipb.InstanceSetting_TagsSetting_{
					TagsSetting: &apipb.InstanceSetting_TagsSetting{
						Tags: map[string]*apipb.InstanceSetting_TagMetadata{
							"bug": {
								BackgroundColor: &colorpb.Color{
									Red:   0.9,
									Green: 0.1,
									Blue:  0.1,
								},
							},
						},
					},
				},
			},
			UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"tags"}},
		})
		require.NoError(t, err)
		require.NotNil(t, resp.GetTagsSetting())
		require.Contains(t, resp.GetTagsSetting().GetTags(), "bug")
	})

	t.Run("UpdateInstanceSetting - invalid tags color", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		_, err = ts.Service.UpdateInstanceSetting(ts.CreateUserContext(ctx, hostUser.ID), &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/TAGS",
				Value: &apipb.InstanceSetting_TagsSetting_{
					TagsSetting: &apipb.InstanceSetting_TagsSetting{
						Tags: map[string]*apipb.InstanceSetting_TagMetadata{
							"bug": {
								BackgroundColor: &colorpb.Color{
									Red:   1.2,
									Green: 0.1,
									Blue:  0.1,
								},
							},
						},
					},
				},
			},
		})
		require.Error(t, err)
		require.Contains(t, err.Error(), "invalid instance setting")
	})

	t.Run("UpdateInstanceSetting - tags setting without color", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)

		resp, err := ts.Service.UpdateInstanceSetting(ts.CreateUserContext(ctx, hostUser.ID), &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/TAGS",
				Value: &apipb.InstanceSetting_TagsSetting_{
					TagsSetting: &apipb.InstanceSetting_TagsSetting{
						Tags: map[string]*apipb.InstanceSetting_TagMetadata{
							"spoiler": {
								BlurContent: true,
							},
						},
					},
				},
			},
		})
		require.NoError(t, err)
		require.NotNil(t, resp.GetTagsSetting())
		require.Contains(t, resp.GetTagsSetting().GetTags(), "spoiler")
		require.Nil(t, resp.GetTagsSetting().GetTags()["spoiler"].GetBackgroundColor())
		require.True(t, resp.GetTagsSetting().GetTags()["spoiler"].GetBlurContent())
	})

	t.Run("UpdateInstanceSetting - notification setting password is write-only", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

		// Save notification setting with a password.
		resp, err := ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/NOTIFICATION",
				Value: &apipb.InstanceSetting_NotificationSetting_{
					NotificationSetting: &apipb.InstanceSetting_NotificationSetting{
						Email: &apipb.InstanceSetting_NotificationSetting_EmailSetting{
							Enabled:      true,
							SmtpHost:     "smtp.example.com",
							SmtpPort:     587,
							SmtpUsername: "[email protected]",
							SmtpPassword: "secret",
							FromEmail:    "[email protected]",
							FromName:     "Memos Bot",
							ReplyTo:      "[email protected]",
							UseTls:       true,
						},
					},
				},
			},
			UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"notification_setting"}},
		})
		require.NoError(t, err)
		require.True(t, resp.GetNotificationSetting().GetEmail().GetEnabled())
		require.Equal(t, "smtp.example.com", resp.GetNotificationSetting().GetEmail().GetSmtpHost())
		// Password must not be returned even in the update response.
		require.Empty(t, resp.GetNotificationSetting().GetEmail().GetSmtpPassword(),
			"SmtpPassword must never be returned in responses")
	})

	t.Run("UpdateInstanceSetting - empty password preserves existing credential", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

		notificationSetting := &apipb.InstanceSetting{
			Name: "instance/settings/NOTIFICATION",
			Value: &apipb.InstanceSetting_NotificationSetting_{
				NotificationSetting: &apipb.InstanceSetting_NotificationSetting{
					Email: &apipb.InstanceSetting_NotificationSetting_EmailSetting{
						Enabled:      true,
						SmtpHost:     "smtp.example.com",
						SmtpPort:     587,
						SmtpUsername: "[email protected]",
						SmtpPassword: "original-password",
						FromEmail:    "[email protected]",
					},
				},
			},
		}

		// First save with a real password.
		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: notificationSetting,
		})
		require.NoError(t, err)

		// Second update with an empty password (simulating a UI that doesn't re-send the secret).
		notificationSetting.GetNotificationSetting().GetEmail().SmtpPassword = ""
		notificationSetting.GetNotificationSetting().GetEmail().FromName = "Updated Bot"
		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: notificationSetting,
		})
		require.NoError(t, err)

		// The stored setting should have preserved the original password.
		stored, err := ts.Store.GetInstanceNotificationSetting(ctx)
		require.NoError(t, err)
		require.Equal(t, "original-password", stored.GetEmail().GetSmtpPassword(),
			"existing SmtpPassword must be preserved when an empty value is sent")
		require.Equal(t, "Updated Bot", stored.GetEmail().GetFromName())
	})

	t.Run("UpdateInstanceSetting - empty password rejected when SMTP identity changes", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

		notificationSetting := &apipb.InstanceSetting{
			Name: "instance/settings/NOTIFICATION",
			Value: &apipb.InstanceSetting_NotificationSetting_{
				NotificationSetting: &apipb.InstanceSetting_NotificationSetting{
					Email: &apipb.InstanceSetting_NotificationSetting_EmailSetting{
						Enabled:      true,
						SmtpHost:     "smtp.example.com",
						SmtpPort:     587,
						SmtpUsername: "[email protected]",
						SmtpPassword: "original-password",
						FromEmail:    "[email protected]",
						UseTls:       true,
					},
				},
			},
		}

		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: notificationSetting,
		})
		require.NoError(t, err)

		notificationSetting.GetNotificationSetting().GetEmail().SmtpPassword = ""
		notificationSetting.GetNotificationSetting().GetEmail().SmtpHost = "smtp2.example.com"
		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: notificationSetting,
		})
		require.Error(t, err)
		require.Contains(t, err.Error(), "smtp password is required")
	})

	t.Run("UpdateInstanceSetting - S3 secret is write-only and preserved on empty", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

		// Save storage setting with a real secret.
		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/STORAGE",
				Value: &apipb.InstanceSetting_StorageSetting_{
					StorageSetting: &apipb.InstanceSetting_StorageSetting{
						S3Config: &apipb.InstanceSetting_StorageSetting_S3Config{
							AccessKeyId:           "AKID",
							AccessKeySecret:       "super-secret",
							Endpoint:              "s3.example.com",
							Region:                "us-east-1",
							Bucket:                "memos",
							InsecureSkipTlsVerify: true,
						},
					},
				},
			},
		})
		require.NoError(t, err)

		// Read back: secret must not be returned.
		resp, err := ts.Service.GetInstanceSetting(adminCtx, &apipb.GetInstanceSettingRequest{
			Name: "instance/settings/STORAGE",
		})
		require.NoError(t, err)
		require.Empty(t, resp.GetStorageSetting().GetS3Config().GetAccessKeySecret(),
			"AccessKeySecret must never be returned in responses")
		require.True(t, resp.GetStorageSetting().GetS3Config().GetInsecureSkipTlsVerify(),
			"insecure_skip_tls_verify must round-trip through the API")
		var defaultStorage *apipb.InstanceSetting_Storage
		for _, configuredStorage := range resp.GetStorageSetting().GetStorages() {
			if configuredStorage.GetId() == resp.GetStorageSetting().GetDefaultStorageId() {
				defaultStorage = configuredStorage
			}
		}
		require.NotNil(t, defaultStorage)
		require.Empty(t, defaultStorage.GetS3Config().GetAccessKeySecret(),
			"AccessKeySecret must be write-only in named storage responses")

		// Update with empty secret; original must be preserved in the store.
		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/STORAGE",
				Value: &apipb.InstanceSetting_StorageSetting_{
					StorageSetting: &apipb.InstanceSetting_StorageSetting{
						S3Config: &apipb.InstanceSetting_StorageSetting_S3Config{
							AccessKeyId:           "AKID",
							AccessKeySecret:       "", // omitted / not changed
							Endpoint:              "s3-v2.example.com",
							Region:                "us-east-1",
							Bucket:                "memos",
							InsecureSkipTlsVerify: true,
						},
					},
				},
			},
		})
		require.NoError(t, err)

		stored, err := ts.Store.GetInstanceStorageSetting(ctx)
		require.NoError(t, err)
		require.Equal(t, "super-secret", stored.GetS3Config().GetAccessKeySecret(),
			"existing AccessKeySecret must be preserved when an empty value is sent")
		require.Equal(t, "s3-v2.example.com", stored.GetS3Config().GetEndpoint())
		require.True(t, stored.GetS3Config().GetInsecureSkipTlsVerify())
		var s3StorageCount int
		var previousStorageFound bool
		for _, configuredStorage := range stored.GetStorages() {
			if configuredStorage.GetType() == storepb.StorageType_STORAGE_TYPE_S3 {
				s3StorageCount++
			}
			if configuredStorage.GetS3Config().GetEndpoint() == "s3.example.com" {
				previousStorageFound = true
			}
		}
		require.Equal(t, 2, s3StorageCount, "changing the S3 namespace must preserve the previous storage")
		require.True(t, previousStorageFound)
	})

	t.Run("UpdateInstanceSetting - AI provider keys are write-only and preserved on empty", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/AI",
				Value: &apipb.InstanceSetting_AiSetting{
					AiSetting: &apipb.InstanceSetting_AISetting{
						Providers: []*apipb.InstanceSetting_AIProviderConfig{
							{
								Id:     "openai-main",
								Title:  "OpenAI",
								Type:   apipb.InstanceSetting_OPENAI,
								ApiKey: "sk-original",
							},
						},
					},
				},
			},
		})
		require.NoError(t, err)

		resp, err := ts.Service.GetInstanceSetting(adminCtx, &apipb.GetInstanceSettingRequest{
			Name: "instance/settings/AI",
		})
		require.NoError(t, err)
		require.Len(t, resp.GetAiSetting().GetProviders(), 1)
		provider := resp.GetAiSetting().GetProviders()[0]
		require.Empty(t, provider.GetApiKey(), "AI provider API key must never be returned in responses")
		require.True(t, provider.GetApiKeySet())
		require.Equal(t, "sk-o...inal", provider.GetApiKeyHint())
		require.Equal(t, "https://api.openai.com/v1", provider.GetEndpoint())

		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/AI",
				Value: &apipb.InstanceSetting_AiSetting{
					AiSetting: &apipb.InstanceSetting_AISetting{
						Providers: []*apipb.InstanceSetting_AIProviderConfig{
							{
								Id:     "openai-main",
								Title:  "OpenAI primary",
								Type:   apipb.InstanceSetting_OPENAI,
								ApiKey: "",
							},
						},
					},
				},
			},
		})
		require.NoError(t, err)

		stored, err := ts.Store.GetInstanceAISetting(ctx)
		require.NoError(t, err)
		require.Len(t, stored.GetProviders(), 1)
		require.Equal(t, "sk-original", stored.GetProviders()[0].GetApiKey(),
			"existing AI provider API key must be preserved when an empty value is sent")
		require.Equal(t, "OpenAI primary", stored.GetProviders()[0].GetTitle())
	})

	t.Run("UpdateInstanceSetting - transcription provider_id must reference an existing provider", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/AI",
				Value: &apipb.InstanceSetting_AiSetting{
					AiSetting: &apipb.InstanceSetting_AISetting{
						Providers: []*apipb.InstanceSetting_AIProviderConfig{
							{
								Id:     "openai-main",
								Title:  "OpenAI",
								Type:   apipb.InstanceSetting_OPENAI,
								ApiKey: "sk-test",
							},
						},
						Transcription: &apipb.InstanceSetting_TranscriptionConfig{
							ProviderId: "does-not-exist",
						},
					},
				},
			},
		})
		require.Error(t, err)
		require.Contains(t, err.Error(), "transcription provider_id")
	})

	t.Run("UpdateInstanceSetting - transcription strings are length-capped", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

		base := &apipb.InstanceSetting{
			Name: "instance/settings/AI",
			Value: &apipb.InstanceSetting_AiSetting{
				AiSetting: &apipb.InstanceSetting_AISetting{
					Providers: []*apipb.InstanceSetting_AIProviderConfig{
						{
							Id:     "openai-main",
							Title:  "OpenAI",
							Type:   apipb.InstanceSetting_OPENAI,
							ApiKey: "sk-test",
						},
					},
				},
			},
		}

		oversizedModel := strings.Repeat("a", 257)
		base.GetAiSetting().Transcription = &apipb.InstanceSetting_TranscriptionConfig{
			ProviderId: "openai-main",
			Model:      oversizedModel,
		}
		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{InstanceSetting: base})
		require.Error(t, err)
		require.Contains(t, err.Error(), "transcription model")

		oversizedLanguage := strings.Repeat("a", 33)
		base.GetAiSetting().Transcription = &apipb.InstanceSetting_TranscriptionConfig{
			ProviderId: "openai-main",
			Language:   oversizedLanguage,
		}
		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{InstanceSetting: base})
		require.Error(t, err)
		require.Contains(t, err.Error(), "transcription language")

		oversizedPrompt := strings.Repeat("a", 4097)
		base.GetAiSetting().Transcription = &apipb.InstanceSetting_TranscriptionConfig{
			ProviderId: "openai-main",
			Prompt:     oversizedPrompt,
		}
		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{InstanceSetting: base})
		require.Error(t, err)
		require.Contains(t, err.Error(), "transcription prompt")
	})

	t.Run("UpdateInstanceSetting - transcription is preserved when omitted on update", func(t *testing.T) {
		ts := NewTestService(t)
		defer ts.Cleanup()

		hostUser, err := ts.CreateHostUser(ctx, "admin")
		require.NoError(t, err)
		adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/AI",
				Value: &apipb.InstanceSetting_AiSetting{
					AiSetting: &apipb.InstanceSetting_AISetting{
						Providers: []*apipb.InstanceSetting_AIProviderConfig{
							{
								Id:     "openai-main",
								Title:  "OpenAI",
								Type:   apipb.InstanceSetting_OPENAI,
								ApiKey: "sk-test",
							},
						},
						Transcription: &apipb.InstanceSetting_TranscriptionConfig{
							ProviderId: "openai-main",
							Model:      "whisper-1",
							Language:   "en",
							Prompt:     "names: Alice",
						},
					},
				},
			},
		})
		require.NoError(t, err)

		_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/AI",
				Value: &apipb.InstanceSetting_AiSetting{
					AiSetting: &apipb.InstanceSetting_AISetting{
						Providers: []*apipb.InstanceSetting_AIProviderConfig{
							{
								Id:     "openai-main",
								Title:  "OpenAI",
								Type:   apipb.InstanceSetting_OPENAI,
								ApiKey: "",
							},
						},
					},
				},
			},
		})
		require.NoError(t, err)

		stored, err := ts.Store.GetInstanceAISetting(ctx)
		require.NoError(t, err)
		require.NotNil(t, stored.GetTranscription())
		require.Equal(t, "openai-main", stored.GetTranscription().GetProviderId())
		require.Equal(t, "whisper-1", stored.GetTranscription().GetModel())
		require.Equal(t, "en", stored.GetTranscription().GetLanguage())
		require.Equal(t, "names: Alice", stored.GetTranscription().GetPrompt())
	})
}

func TestUpdateInstanceSettingValidatesStorages(t *testing.T) {
	ctx := context.Background()
	ts := NewTestService(t)
	defer ts.Cleanup()
	hostUser, err := ts.CreateHostUser(ctx, "admin")
	require.NoError(t, err)
	adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

	update := func(storages []*apipb.InstanceSetting_Storage, defaultID string) error {
		_, err := ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{
			InstanceSetting: &apipb.InstanceSetting{
				Name: "instance/settings/STORAGE",
				Value: &apipb.InstanceSetting_StorageSetting_{StorageSetting: &apipb.InstanceSetting_StorageSetting{
					Storages:         storages,
					DefaultStorageId: defaultID,
				}},
			},
		})
		return err
	}
	local := &apipb.InstanceSetting_Storage{Id: "local", Type: apipb.InstanceSetting_LOCAL}
	archive := &apipb.InstanceSetting_Storage{
		Id:   "archive",
		Type: apipb.InstanceSetting_S3,
		Config: &apipb.InstanceSetting_Storage_S3Config_{S3Config: &apipb.InstanceSetting_Storage_S3Config{
			AccessKeyId: "AKID", AccessKeySecret: "secret", Endpoint: "https://s3.example.com", Bucket: "memos",
		}},
	}

	// A non-default S3 storage without a region would fail on first use.
	err = update([]*apipb.InstanceSetting_Storage{local, archive}, "local")
	require.Equal(t, codes.InvalidArgument, status.Code(err))
	require.Contains(t, err.Error(), "storage archive region is required")

	archive.GetS3Config().Region = "us-east-1"
	require.NoError(t, update([]*apipb.InstanceSetting_Storage{local, archive}, "local"))
}

func TestConfigurationStateIsNotExposed(t *testing.T) {
	ctx := context.Background()
	ts := NewTestService(t)
	defer ts.Cleanup()
	hostUser, err := ts.CreateHostUser(ctx, "admin")
	require.NoError(t, err)
	adminCtx := ts.CreateUserContext(ctx, hostUser.ID)

	_, err = ts.Store.RunConfigurationTransaction(ctx, func(context.Context, *store.ConfigurationTransaction) (*storepb.InstanceConfigurationState, error) {
		return &storepb.InstanceConfigurationState{ConfigDigest: "digest"}, nil
	})
	require.NoError(t, err)

	const name = "instance/settings/CONFIGURATION_STATE"
	_, err = ts.Service.GetInstanceSetting(adminCtx, &apipb.GetInstanceSettingRequest{Name: name})
	require.Equal(t, codes.InvalidArgument, status.Code(err))
	_, err = ts.Service.BatchGetInstanceSettings(adminCtx, &apipb.BatchGetInstanceSettingsRequest{Names: []string{name}})
	require.Equal(t, codes.InvalidArgument, status.Code(err))
	_, err = ts.Service.UpdateInstanceSetting(adminCtx, &apipb.UpdateInstanceSettingRequest{InstanceSetting: &apipb.InstanceSetting{Name: name}})
	require.Equal(t, codes.InvalidArgument, status.Code(err))
	require.Contains(t, err.Error(), "state record and cannot be written")

	state, err := ts.Store.GetConfigurationState(ctx)
	require.NoError(t, err)
	require.Equal(t, "digest", state.ConfigDigest, "the API did not overwrite the record")
}