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.

chore: add migration tests

boojackd566184a45c5
diff --git a/store/test/README.md b/store/test/README.md
index 988c63177..8adee757f 100644
--- a/store/test/README.md
+++ b/store/test/README.md
@@ -1,13 +1,25 @@
# Store tests
-## How to test store with MySQL?
+Run from the repository root. Docker must be running for MySQL, PostgreSQL, and released-binary upgrade tests.
-1. Create a database in your MySQL server.
-2. Run the following command with two environment variables set:
+```bash
+go test -v ./store/... # SQLite, MySQL, and PostgreSQL; TestContainers creates isolated databases
+DRIVER=mysql go test -v ./store/test/... # One driver only
+```
+
+## Upgrade coverage
-```go
-DRIVER=mysql DSN=root@/memos_test go test -v ./test/store/...
+```bash
+DRIVER=sqlite go test -v -count=1 -timeout 30m -run 'TestMigration|TestUpgrade|TestFreshInstall' ./store/test/...
```
-- `DRIVER` should be set to `mysql`.
-- `DSN` should be set to the DSN of your MySQL server.
+Use `DRIVER=mysql` or `DRIVER=postgres` for the other drivers. The existing Upgrade Smoke workflow runs this selection for
+all three drivers before release.
+
+- Before `v0.31.0`: `TestUpgradeThroughBaselineRelease` initializes a database with released `0.30.0`, verifies the current
+ migrator refuses a direct upgrade without modifying data or settings, then upgrades through released `0.31.0` to current.
+- From `v0.31.0`: `TestUpgradeFromBaselineRelease` initializes a database with released `0.31.0`, then checks preservation of
+ the account, memo, saved View, and access mode, post-upgrade writes, and reopening the database after upgrade.
+- From CalVer: `TestUpgradeFromCalendarRelease` uses local store fixtures for month changes, point releases, RC promotion,
+ and year changes. It checks the same preservation and restart behavior. These are fixtures, not published CalVer binaries;
+ application versions advance while the current database schema remains `0.31.8`.
diff --git a/store/test/migrator_upgrade_test.go b/store/test/migrator_upgrade_test.go
index 86663546e..9b5697bbd 100644
--- a/store/test/migrator_upgrade_test.go
+++ b/store/test/migrator_upgrade_test.go
@@ -1,12 +1,155 @@
package test
import (
+ "context"
"fmt"
"testing"
"github.com/stretchr/testify/require"
+ "google.golang.org/protobuf/proto"
+
+ "github.com/usememos/memos/internal/profile"
+ storepb "github.com/usememos/memos/proto/gen/store"
+ "github.com/usememos/memos/store"
+ storedb "github.com/usememos/memos/store/db"
)
+// TestUpgradeFromBaselineRelease tests a database initialized by v0.31.0
+// directly, independently of the pre-baseline intermediate upgrade test.
+func TestUpgradeFromBaselineRelease(t *testing.T) {
+ if testing.Short() {
+ t.Skip("skipping container-based upgrade test in short mode")
+ }
+ skipIfContainerProviderUnavailable(t)
+
+ ctx := context.Background()
+ driver := getDriverFromEnv()
+ cfg, hostDSN := prepareUpgradeFixture(t, driver, "0.31.0")
+ container, err := StartMemosContainer(ctx, cfg)
+ require.NoError(t, err)
+ t.Cleanup(func() {
+ if container != nil {
+ _ = container.Terminate(ctx)
+ }
+ })
+ require.NoError(t, container.Terminate(ctx))
+ container = nil
+
+ previous := NewTestingStoreWithDSN(ctx, t, driver, hostDSN)
+ t.Cleanup(func() { _ = previous.Close() })
+ baseline, err := previous.GetInstanceBasicSetting(ctx)
+ require.NoError(t, err)
+ require.Equal(t, "0.31.8", baseline.SchemaVersion)
+
+ requireUpgradePreservesData(ctx, t, previous, &profile.Profile{
+ Data: t.TempDir(), DSN: hostDSN, Driver: driver, Version: "26.10",
+ })
+}
+
+// TestUpgradeFromCalendarRelease uses local store fixtures until a published
+// CalVer release is available. Application versions do not advance the schema:
+// the first CalVer releases retain v0.31.0's schema unless migrations are added.
+func TestUpgradeFromCalendarRelease(t *testing.T) {
+ for _, tc := range []struct{ previous, candidate string }{
+ {previous: "26.09", candidate: "26.10"},
+ {previous: "26.10", candidate: "26.10.1"},
+ {previous: "26.10-rc.1", candidate: "26.10"},
+ {previous: "26.12.9", candidate: "27.01"},
+ } {
+ t.Run(tc.previous+"-to-"+tc.candidate, func(t *testing.T) {
+ t.Parallel()
+ ctx := context.Background()
+ previousProfile := getTestingProfileForDriver(t, getDriverFromEnv())
+ previousProfile.Version = tc.previous
+ previousDriver, err := storedb.NewDBDriver(previousProfile)
+ require.NoError(t, err)
+ previous := store.New(previousDriver, previousProfile)
+ t.Cleanup(func() { _ = previous.Close() })
+ require.NoError(t, previous.Migrate(ctx))
+ baseline, err := previous.GetInstanceBasicSetting(ctx)
+ require.NoError(t, err)
+ require.Equal(t, "0.31.8", baseline.SchemaVersion, "application CalVer must not become the database schema version")
+
+ candidateProfile := *previousProfile
+ candidateProfile.Version = tc.candidate
+ requireUpgradePreservesData(ctx, t, previous, &candidateProfile)
+ })
+ }
+}
+
+// requireUpgradePreservesData closes the source store and opens the same
+// database with the candidate profile, then checks upgrade and restart behavior.
+func requireUpgradePreservesData(ctx context.Context, t *testing.T, previous *store.Store, candidateProfile *profile.Profile) {
+ t.Helper()
+ user, err := createTestingHostUser(ctx, previous)
+ require.NoError(t, err)
+ memo, err := previous.CreateMemo(ctx, &store.Memo{
+ UID: "upgrade-sentinel", CreatorID: user.ID, Content: "#upgrade\n- [ ] preserved task", Visibility: store.Private, Pinned: true,
+ })
+ require.NoError(t, err)
+ memo, err = previous.GetMemo(ctx, &store.FindMemo{UID: &memo.UID})
+ require.NoError(t, err)
+ view, err := previous.UpsertUserSetting(ctx, &storepb.UserSetting{
+ UserId: user.ID, Key: storepb.UserSetting_MEMO_VIEWS,
+ Value: &storepb.UserSetting_MemoViews{MemoViews: &storepb.MemoViewsUserSetting{
+ MemoViews: []*storepb.MemoViewsUserSetting_MemoView{{Id: "upgrade", Title: "Upgrade sentinel", Filter: "has_incomplete_tasks"}},
+ }},
+ })
+ require.NoError(t, err)
+ access, err := previous.UpsertInstanceSetting(ctx, &storepb.InstanceSetting{
+ Key: storepb.InstanceSettingKey_ACCESS,
+ Value: &storepb.InstanceSetting_AccessSetting{AccessSetting: &storepb.InstanceAccessSetting{
+ AccessMode: storepb.InstanceAccessMode_INSTANCE_ACCESS_MODE_PUBLIC,
+ }},
+ })
+ require.NoError(t, err)
+ require.NoError(t, previous.Close())
+
+ verify := func(candidate *store.Store) {
+ t.Helper()
+ currentSchema, err := candidate.GetCurrentSchemaVersion()
+ require.NoError(t, err)
+ basic, err := candidate.GetInstanceBasicSetting(ctx)
+ require.NoError(t, err)
+ require.Equal(t, currentSchema, basic.SchemaVersion)
+ preservedUser, err := candidate.GetUser(ctx, &store.FindUser{ID: &user.ID})
+ require.NoError(t, err)
+ require.Equal(t, user, preservedUser)
+ preservedMemo, err := candidate.GetMemo(ctx, &store.FindMemo{UID: &memo.UID})
+ require.NoError(t, err)
+ require.Equal(t, memo, preservedMemo)
+ preservedView, err := candidate.GetUserSetting(ctx, &store.FindUserSetting{UserID: &user.ID, Key: storepb.UserSetting_MEMO_VIEWS})
+ require.NoError(t, err)
+ require.True(t, proto.Equal(view, preservedView), "saved Views must survive the upgrade")
+ preservedAccess, err := candidate.GetInstanceAccessSetting(ctx)
+ require.NoError(t, err)
+ require.True(t, proto.Equal(access.GetAccessSetting(), preservedAccess), "explicit access mode must not be reset")
+ }
+
+ driver, err := storedb.NewDBDriver(candidateProfile)
+ require.NoError(t, err)
+ candidate := store.New(driver, candidateProfile)
+ t.Cleanup(func() { _ = candidate.Close() })
+ require.NoError(t, candidate.Migrate(ctx))
+ verify(candidate)
+ written, err := candidate.CreateMemo(ctx, &store.Memo{
+ UID: "after-upgrade", CreatorID: user.ID, Content: "created after upgrade", Visibility: store.Private,
+ })
+ require.NoError(t, err, "upgraded database must remain writable")
+ require.NoError(t, candidate.Close())
+
+ restartedDriver, err := storedb.NewDBDriver(candidateProfile)
+ require.NoError(t, err)
+ restarted := store.New(restartedDriver, candidateProfile)
+ t.Cleanup(func() { _ = restarted.Close() })
+ require.NoError(t, restarted.Migrate(ctx), "restart after upgrade must be idempotent")
+ verify(restarted)
+ persisted, err := restarted.GetMemo(ctx, &store.FindMemo{UID: &written.UID})
+ require.NoError(t, err)
+ require.NotNil(t, persisted)
+ require.Equal(t, written.Content, persisted.Content, "post-upgrade writes must survive restart")
+}
+
// prepareUpgradeFixture returns the container config needed to bootstrap a real
// schema for the given Memos version, plus the DSN the host uses to reach it.
func prepareUpgradeFixture(t *testing.T, driver, version string) (MemosContainerConfig, string) {