mirror of
https://github.com/usememos/memos.git
synced 2026-11-19 18:39:12 +01:00
9e3a164dff
Move memo content size into usage limits, with 8 KiB content and 32 MiB upload defaults when settings are absent. Represent stored rule targets with all_users or a positive user_id, and use that same schema for deployment configuration. Rename the memo count metric, remove reserved proto declarations, and renumber fields and enums for the unreleased schema. Synchronize enforcement, settings UI, generated clients, and tests.
1112 lines
37 KiB
Go
1112 lines
37 KiB
Go
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"
|
|
)
|
|
|
|
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 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 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 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(ctx, 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
|
|
_, err := ts.CreateHostUser(ctx, "admin")
|
|
require.NoError(t, err)
|
|
|
|
// 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(ctx, 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: "bot@example.com",
|
|
SmtpPassword: "stored-password",
|
|
FromEmail: "bot@example.com",
|
|
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: "bot@example.com",
|
|
SmtpPassword: "",
|
|
FromEmail: "bot@example.com",
|
|
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: "bot@example.com",
|
|
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 useTls and useSsl")
|
|
|
|
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 smtpHost", "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: "bot@example.com",
|
|
SmtpPassword: "secret",
|
|
FromEmail: "bot@example.com",
|
|
FromName: "Memos Bot",
|
|
ReplyTo: "support@example.com",
|
|
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: "bot@example.com",
|
|
SmtpPassword: "original-password",
|
|
FromEmail: "bot@example.com",
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
// 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: "bot@example.com",
|
|
SmtpPassword: "original-password",
|
|
FromEmail: "bot@example.com",
|
|
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())
|
|
})
|
|
}
|