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.

10.6 KB
Raw Blame
package test

import (
	"context"
	"testing"

	"github.com/stretchr/testify/require"
	colorpb "google.golang.org/genproto/googleapis/type/color"
	"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/server/api"
)

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

	user, err := ts.CreateRegularUser(ctx, "locale-user")
	require.NoError(t, err)

	_, err = ts.Store.UpsertUserSetting(ctx, &storepb.UserSetting{
		UserId: user.ID,
		Key:    storepb.UserSetting_REFRESH_TOKENS,
		Value: &storepb.UserSetting_RefreshTokens{
			RefreshTokens: &storepb.RefreshTokensUserSetting{},
		},
	})
	require.NoError(t, err)

	_, err = ts.Store.UpsertUserSetting(ctx, &storepb.UserSetting{
		UserId: user.ID,
		Key:    storepb.UserSetting_MEMO_VIEWS,
		Value: &storepb.UserSetting_MemoViews{
			MemoViews: &storepb.MemoViewsUserSetting{},
		},
	})
	require.NoError(t, err)

	_, err = ts.Store.UpsertUserSetting(ctx, &storepb.UserSetting{
		UserId: user.ID,
		Key:    storepb.UserSetting_GENERAL,
		Value: &storepb.UserSetting_General{
			General: &storepb.GeneralUserSetting{
				Locale: "ja",
			},
		},
	})
	require.NoError(t, err)

	resp, err := ts.Service.ListUserSettings(ts.CreateUserContext(ctx, user.ID), &apipb.ListUserSettingsRequest{
		Parent: api.BuildUserName(user.Username),
	})
	require.NoError(t, err)
	require.Len(t, resp.UserSettings, 1)
	require.Equal(t, "users/locale-user/settings/GENERAL", resp.UserSettings[0].Name)
	require.Equal(t, "ja", resp.UserSettings[0].GetGeneralSetting().Locale)
}

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

	user, err := ts.CreateRegularUser(ctx, "media-setting-user")
	require.NoError(t, err)
	userCtx := ts.CreateUserContext(ctx, user.ID)
	settingName := "users/media-setting-user/settings/GENERAL"

	defaultSetting, err := ts.Service.GetUserSetting(userCtx, &apipb.GetUserSettingRequest{Name: settingName})
	require.NoError(t, err)
	require.False(t, defaultSetting.GetGeneralSetting().GetSaveMediaMetadata())

	updated, err := ts.Service.UpdateUserSetting(userCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: &apipb.UserSetting{
			Name: settingName,
			Value: &apipb.UserSetting_GeneralSetting_{
				GeneralSetting: &apipb.UserSetting_GeneralSetting{SaveMediaMetadata: true},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"save_media_metadata"}},
	})
	require.NoError(t, err)
	require.True(t, updated.GetGeneralSetting().GetSaveMediaMetadata())
	require.Equal(t, "en", updated.GetGeneralSetting().GetLocale())
	require.Equal(t, "PRIVATE", updated.GetGeneralSetting().GetMemoVisibility())

	updated, err = ts.Service.UpdateUserSetting(userCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: &apipb.UserSetting{
			Name: settingName,
			Value: &apipb.UserSetting_GeneralSetting_{
				GeneralSetting: &apipb.UserSetting_GeneralSetting{Locale: "ja"},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"locale"}},
	})
	require.NoError(t, err)
	require.Equal(t, "ja", updated.GetGeneralSetting().GetLocale())
	require.True(t, updated.GetGeneralSetting().GetSaveMediaMetadata())

	updated, err = ts.Service.UpdateUserSetting(userCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: &apipb.UserSetting{
			Name: settingName,
			Value: &apipb.UserSetting_GeneralSetting_{
				GeneralSetting: &apipb.UserSetting_GeneralSetting{SaveMediaMetadata: false},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"save_media_metadata"}},
	})
	require.NoError(t, err)
	require.False(t, updated.GetGeneralSetting().GetSaveMediaMetadata())
}

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

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

	tagsSetting := &apipb.UserSetting{
		Name: "users/tag-user/settings/TAGS",
		Value: &apipb.UserSetting_TagsSetting_{
			TagsSetting: &apipb.UserSetting_TagsSetting{
				Tags: map[string]*apipb.UserSetting_TagMetadata{
					"bug": {
						BackgroundColor: &colorpb.Color{
							Red:   0.9,
							Green: 0.1,
							Blue:  0.1,
						},
					},
					"private/.*": {
						BlurContent: true,
					},
				},
			},
		},
	}

	updated, err := ts.Service.UpdateUserSetting(userCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: tagsSetting,
		UpdateMask:  &fieldmaskpb.FieldMask{Paths: []string{"tags"}},
	})
	require.NoError(t, err)
	require.Equal(t, "users/tag-user/settings/TAGS", updated.Name)
	require.Contains(t, updated.GetTagsSetting().GetTags(), "bug")
	require.True(t, updated.GetTagsSetting().GetTags()["private/.*"].BlurContent)

	got, err := ts.Service.GetUserSetting(userCtx, &apipb.GetUserSettingRequest{Name: "users/tag-user/settings/TAGS"})
	require.NoError(t, err)
	require.Contains(t, got.GetTagsSetting().GetTags(), "bug")

	resp, err := ts.Service.ListUserSettings(userCtx, &apipb.ListUserSettingsRequest{
		Parent: api.BuildUserName(user.Username),
	})
	require.NoError(t, err)
	var foundTags bool
	for _, setting := range resp.UserSettings {
		if setting.GetTagsSetting() != nil {
			foundTags = true
			require.Equal(t, "users/tag-user/settings/TAGS", setting.Name)
		}
	}
	require.True(t, foundTags)
}

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

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

	_, err = ts.Service.UpdateUserSetting(userCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: &apipb.UserSetting{
			Name: "users/invalid-tag-user/settings/TAGS",
			Value: &apipb.UserSetting_TagsSetting_{
				TagsSetting: &apipb.UserSetting_TagsSetting{
					Tags: map[string]*apipb.UserSetting_TagMetadata{
						"(": {},
					},
				},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"tags"}},
	})
	require.Error(t, err)
	require.Contains(t, err.Error(), "invalid")

	_, err = ts.Service.UpdateUserSetting(userCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: &apipb.UserSetting{
			Name: "users/invalid-tag-user/settings/TAGS",
			Value: &apipb.UserSetting_TagsSetting_{
				TagsSetting: &apipb.UserSetting_TagsSetting{
					Tags: map[string]*apipb.UserSetting_TagMetadata{
						"bug": {
							BackgroundColor: &colorpb.Color{Red: 1.2},
						},
					},
				},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"tags"}},
	})
	require.Error(t, err)
	require.Contains(t, err.Error(), "invalid")

	_, err = ts.Service.UpdateUserSetting(userCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: &apipb.UserSetting{
			Name: "users/invalid-tag-user/settings/TAGS",
			Value: &apipb.UserSetting_TagsSetting_{
				TagsSetting: &apipb.UserSetting_TagsSetting{
					Tags: map[string]*apipb.UserSetting_TagMetadata{
						"bug": {},
					},
				},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"locale"}},
	})
	require.Error(t, err)
	require.Contains(t, err.Error(), "unsupported update mask path")
}

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

	_, err := ts.CreateRegularUser(ctx, "tag-owner")
	require.NoError(t, err)
	other, err := ts.CreateRegularUser(ctx, "tag-other")
	require.NoError(t, err)
	otherCtx := ts.CreateUserContext(ctx, other.ID)

	_, err = ts.Service.GetUserSetting(otherCtx, &apipb.GetUserSettingRequest{Name: "users/tag-owner/settings/TAGS"})
	require.Error(t, err)
	require.Contains(t, err.Error(), "permission denied")

	_, err = ts.Service.UpdateUserSetting(otherCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: &apipb.UserSetting{
			Name: "users/tag-owner/settings/TAGS",
			Value: &apipb.UserSetting_TagsSetting_{
				TagsSetting: &apipb.UserSetting_TagsSetting{
					Tags: map[string]*apipb.UserSetting_TagMetadata{"bug": {}},
				},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"tags"}},
	})
	require.Error(t, err)
	require.Contains(t, err.Error(), "permission denied")
}

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

	user, err := ts.CreateRegularUser(ctx, "editor-user")
	require.NoError(t, err)
	userCtx := ts.CreateUserContext(ctx, user.ID)
	settingName := "users/editor-user/settings/EDITOR"

	defaultSetting, err := ts.Service.GetUserSetting(userCtx, &apipb.GetUserSettingRequest{Name: settingName})
	require.NoError(t, err)
	require.Equal(t, settingName, defaultSetting.Name)
	require.NotNil(t, defaultSetting.GetEditorSetting())
	require.False(t, defaultSetting.GetEditorSetting().GetSourceMode())

	// An unset editor setting is not listed.
	listed, err := ts.Service.ListUserSettings(userCtx, &apipb.ListUserSettingsRequest{Parent: api.BuildUserName(user.Username)})
	require.NoError(t, err)
	for _, setting := range listed.UserSettings {
		require.Nil(t, setting.GetEditorSetting())
	}

	updated, err := ts.Service.UpdateUserSetting(userCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: &apipb.UserSetting{
			Name: settingName,
			Value: &apipb.UserSetting_EditorSetting_{
				EditorSetting: &apipb.UserSetting_EditorSetting{SourceMode: true},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"source_mode"}},
	})
	require.NoError(t, err)
	require.True(t, updated.GetEditorSetting().GetSourceMode())

	listed, err = ts.Service.ListUserSettings(userCtx, &apipb.ListUserSettingsRequest{Parent: api.BuildUserName(user.Username)})
	require.NoError(t, err)
	var listedEditor *apipb.UserSetting
	for _, setting := range listed.UserSettings {
		if setting.GetEditorSetting() != nil {
			listedEditor = setting
		}
	}
	require.NotNil(t, listedEditor)
	require.Equal(t, settingName, listedEditor.Name)
	require.True(t, listedEditor.GetEditorSetting().GetSourceMode())

	_, err = ts.Service.UpdateUserSetting(userCtx, &apipb.UpdateUserSettingRequest{
		UserSetting: &apipb.UserSetting{
			Name: settingName,
			Value: &apipb.UserSetting_EditorSetting_{
				EditorSetting: &apipb.UserSetting_EditorSetting{},
			},
		},
		UpdateMask: &fieldmaskpb.FieldMask{Paths: []string{"theme"}},
	})
	require.Error(t, err)
	require.Contains(t, err.Error(), "unsupported update mask path")

	other, err := ts.CreateRegularUser(ctx, "editor-other")
	require.NoError(t, err)
	otherCtx := ts.CreateUserContext(ctx, other.ID)
	_, err = ts.Service.GetUserSetting(otherCtx, &apipb.GetUserSettingRequest{Name: settingName})
	require.Error(t, err)
	require.Contains(t, err.Error(), "permission denied")
}