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.
Go dockerfossgomarkdownmemomicroblognote-takingnotesopen-sourceown-your-datareactself-hostedsqlitetimeline
package test
import (
"context"
"database/sql"
"testing"
"github.com/stretchr/testify/require"
storepb "github.com/usememos/memos/proto/gen/store"
"github.com/usememos/memos/store"
storedb "github.com/usememos/memos/store/db"
)
type delayedInstanceSettingCreateDriver struct {
store.Driver
entered chan<- struct{}
release <-chan struct{}
}
func (d *delayedInstanceSettingCreateDriver) CreateInstanceSettingIfNotExists(ctx context.Context, create *store.InstanceSetting) (bool, error) {
d.entered <- struct{}{}
<-d.release
return d.Driver.CreateInstanceSettingIfNotExists(ctx, create)
}
func requireQueryError(ctx context.Context, t *testing.T, db *sql.DB, query, message string) {
t.Helper()
rows, err := db.QueryContext(ctx, query)
if rows != nil {
defer rows.Close()
require.NoError(t, rows.Err())
}
require.Error(t, err, message)
}
// TestFreshInstall verifies that LATEST.sql applies correctly on a fresh database.
// This is essentially what NewTestingStore already does, but we make it explicit.
func TestFreshInstall(t *testing.T) {
t.Parallel()
ctx := context.Background()
// NewTestingStore creates a fresh database and runs Migrate()
// which applies LATEST.sql for uninitialized databases
ts := NewTestingStore(ctx, t)
// Verify migration completed successfully
currentSchemaVersion, err := ts.GetCurrentSchemaVersion()
require.NoError(t, err)
require.Equal(t, "26.10.1", currentSchemaVersion, "fresh install should record the latest migration")
// Verify we can read instance settings (basic sanity check)
instanceSetting, err := ts.GetInstanceBasicSetting(ctx)
require.NoError(t, err)
require.Equal(t, currentSchemaVersion, instanceSetting.SchemaVersion)
// The fresh schema supports memo-local Space placement without adding a
// canonical thread shape. COMMENT remains an ordinary relation row.
driver := getDriverFromEnv()
insertSpace := "INSERT INTO space (id, uid, title, description, payload) VALUES (?, ?, ?, ?, '{}')"
insertMemo := "INSERT INTO memo (id, uid, creator_id, content, visibility, payload, space_id) VALUES (?, ?, ?, ?, ?, ?, ?)"
insertRelation := "INSERT INTO memo_relation (memo_id, related_memo_id, type) VALUES (?, ?, ?)"
if driver == "postgres" {
insertSpace = "INSERT INTO space (id, uid, title, description, payload) VALUES ($1, $2, $3, $4, '{}')"
insertMemo = "INSERT INTO memo (id, uid, creator_id, content, visibility, payload, space_id) VALUES ($1, $2, $3, $4, $5, $6, $7)"
insertRelation = "INSERT INTO memo_relation (memo_id, related_memo_id, type) VALUES ($1, $2, $3)"
}
_, err = ts.GetDriver().GetDB().ExecContext(ctx, insertSpace, 900001, "fresh-space", "Fresh Space", "schema fixture")
require.NoError(t, err)
_, err = ts.GetDriver().GetDB().ExecContext(ctx, insertMemo, 900001, "fresh-context", 1, "context", store.Public, `{}`, nil)
require.NoError(t, err)
_, err = ts.GetDriver().GetDB().ExecContext(ctx, insertMemo, 900002, "fresh-comment", 1, "comment", store.SpaceAudience, `{}`, 900001)
require.NoError(t, err)
_, err = ts.GetDriver().GetDB().ExecContext(ctx, insertRelation, 900002, 900001, store.MemoRelationComment)
require.NoError(t, err)
var relationCount int
require.NoError(t, ts.GetDriver().GetDB().QueryRowContext(ctx,
"SELECT COUNT(*) FROM memo_relation WHERE memo_id = 900002 AND related_memo_id = 900001 AND type = 'COMMENT'",
).Scan(&relationCount))
require.Equal(t, 1, relationCount)
requireQueryError(ctx, t, ts.GetDriver().GetDB(), "SELECT parent_memo_id, root_memo_id FROM memo LIMIT 0", "fresh memo schema must not contain canonical-root columns")
requireQueryError(ctx, t, ts.GetDriver().GetDB(), "SELECT row_status FROM space LIMIT 0", "fresh Space schema has no archived state")
requireCreatorIndexes(ctx, t, ts, driver)
}
// requireCreatorIndexes checks the indexes that usage limit checks rely on to
// count a user's memos and sum a user's attachment sizes.
func requireCreatorIndexes(ctx context.Context, t *testing.T, ts *store.Store, driver string) {
t.Helper()
for _, indexName := range []string{"idx_memo_creator_id", "idx_attachment_creator_id"} {
var query string
switch driver {
case "sqlite":
query = "SELECT COUNT(*) FROM sqlite_master WHERE type = 'index' AND name = ?"
case "mysql":
query = "SELECT COUNT(DISTINCT INDEX_NAME) FROM information_schema.STATISTICS WHERE TABLE_SCHEMA = DATABASE() AND INDEX_NAME = ?"
case "postgres":
query = "SELECT COUNT(*) FROM pg_indexes WHERE schemaname = current_schema() AND indexname = $1"
default:
t.Fatalf("unsupported driver: %s", driver)
}
var count int
require.NoError(t, ts.GetDriver().GetDB().QueryRowContext(ctx, query, indexName).Scan(&count))
require.Equal(t, 1, count, "index %s must exist", indexName)
}
}
// TestMigrationReRun verifies that re-running the migration on an already
// migrated database does not fail or cause issues. This simulates a
// scenario where the server is restarted.
func TestMigrationReRun(t *testing.T) {
t.Parallel()
ctx := context.Background()
// Use the shared testing store which already runs migrations on init
ts := NewTestingStore(ctx, t)
// Get current version
initialVersion, err := ts.GetCurrentSchemaVersion()
require.NoError(t, err)
// Manually trigger migration again
err = ts.Migrate(ctx)
require.NoError(t, err, "re-running migration should not fail")
// Verify version hasn't changed (or at least is valid)
finalVersion, err := ts.GetCurrentSchemaVersion()
require.NoError(t, err)
require.Equal(t, initialVersion, finalVersion, "version should match after re-run")
}
// TestMigrationWithData verifies that migration preserves data integrity.
// Creates data, then re-runs migration and verifies data is still accessible.
func TestMigrationWithData(t *testing.T) {
t.Parallel()
ctx := context.Background()
ts := NewTestingStore(ctx, t)
// Create a user and memo before re-running migration
user, err := createTestingHostUser(ctx, ts)
require.NoError(t, err, "should create user")
originalMemo, err := ts.CreateMemo(ctx, &store.Memo{
UID: "migration-data-test",
CreatorID: user.ID,
Content: "Data before migration re-run",
Visibility: store.Public,
})
require.NoError(t, err, "should create memo")
// Re-run migration
err = ts.Migrate(ctx)
require.NoError(t, err, "re-running migration should not fail")
// Verify data is still accessible
memo, err := ts.GetMemo(ctx, &store.FindMemo{UID: &originalMemo.UID})
require.NoError(t, err, "should retrieve memo after migration")
require.Equal(t, "Data before migration re-run", memo.Content, "memo content should be preserved")
}
// TestMigrationMultipleReRuns verifies that migration is idempotent
// even when run multiple times in succession.
func TestMigrationMultipleReRuns(t *testing.T) {
t.Parallel()
ctx := context.Background()
ts := NewTestingStore(ctx, t)
// Get initial version
initialVersion, err := ts.GetCurrentSchemaVersion()
require.NoError(t, err)
// Run migration multiple times
for i := range 3 {
err = ts.Migrate(ctx)
require.NoError(t, err, "migration run %d should not fail", i+1)
}
// Verify version is still correct
finalVersion, err := ts.GetCurrentSchemaVersion()
require.NoError(t, err)
require.Equal(t, initialVersion, finalVersion, "version should remain unchanged after multiple re-runs")
}
func TestConcurrentInstanceAccessInitializationKeepsFirstInsert(t *testing.T) {
ctx := context.Background()
driverName := getDriverFromEnv()
baseProfile := getTestingProfileForDriver(t, driverName)
baseDriver, err := storedb.NewDBDriver(baseProfile)
require.NoError(t, err)
baseStore := store.New(baseDriver, baseProfile)
require.NoError(t, baseStore.Migrate(ctx))
require.NoError(t, baseStore.DeleteInstanceSetting(ctx, &store.DeleteInstanceSetting{
Name: storepb.InstanceSettingKey_ACCESS.String(),
}))
require.NoError(t, baseStore.Close())
publicProfile := *baseProfile
publicProfile.InstanceURL = "https://public.example.com"
publicDriver, err := storedb.NewDBDriver(&publicProfile)
require.NoError(t, err)
entered := make(chan struct{}, 1)
release := make(chan struct{})
delayedPublicDriver := &delayedInstanceSettingCreateDriver{
Driver: publicDriver,
entered: entered,
release: release,
}
publicStore := store.New(delayedPublicDriver, &publicProfile)
defer publicStore.Close()
privateProfile := *baseProfile
privateProfile.InstanceURL = ""
privateDriver, err := storedb.NewDBDriver(&privateProfile)
require.NoError(t, err)
privateStore := store.New(privateDriver, &privateProfile)
defer privateStore.Close()
publicMigration := make(chan error, 1)
go func() {
publicMigration <- publicStore.Migrate(ctx)
}()
<-entered
released := false
defer func() {
if !released {
close(release)
}
}()
// The private instance reaches the database first. The delayed public
// initializer must lose the unique-key race without overwriting it.
require.NoError(t, privateStore.Migrate(ctx))
close(release)
released = true
require.NoError(t, <-publicMigration)
setting, err := privateStore.GetUncachedInstanceSetting(ctx, &store.FindInstanceSetting{
Name: storepb.InstanceSettingKey_ACCESS.String(),
})
require.NoError(t, err)
require.NotNil(t, setting)
require.Equal(t, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE, setting.GetAccessSetting().AccessMode)
// Re-running either initializer is also a no-op once ACCESS is persisted.
require.NoError(t, publicStore.Migrate(ctx))
setting, err = publicStore.GetUncachedInstanceSetting(ctx, &store.FindInstanceSetting{
Name: storepb.InstanceSettingKey_ACCESS.String(),
})
require.NoError(t, err)
require.Equal(t, storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PRIVATE, setting.GetAccessSetting().AccessMode)
}
func TestCheckSchemaCurrent(t *testing.T) {
t.Parallel()
ctx := context.Background()
ts := NewTestingStore(ctx, t)
t.Cleanup(func() { require.NoError(t, ts.Close()) })
require.NoError(t, ts.CheckSchemaCurrent(ctx), "a migrated database is current")
basic, err := ts.GetInstanceBasicSetting(ctx)
require.NoError(t, err)
basic.SchemaVersion = "0.31.8"
_, err = ts.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{Key: storepb.InstanceSettingKey_BASIC, Value: &storepb.InstanceSetting_BasicSetting{BasicSetting: basic}})
require.NoError(t, err)
require.ErrorContains(t, ts.CheckSchemaCurrent(ctx), "start this version of Memos once to migrate it")
}