155 lines
4.5 KiB
Go
155 lines
4.5 KiB
Go
package localdb
|
|
|
|
import (
|
|
"archive/zip"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
"github.com/glebarez/sqlite"
|
|
"gorm.io/gorm"
|
|
)
|
|
|
|
func TestResetProtectsUnsyncedData(t *testing.T) {
|
|
for _, table := range []string{"pending_changes", "local_projects", "local_configurations"} {
|
|
t.Run(table, func(t *testing.T) {
|
|
path, db := resetFixture(t)
|
|
if err := db.Exec("INSERT INTO " + table + " (sync_status) VALUES ('pending')").Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err := ResetDataWithOptions(path, "", false)
|
|
if err == nil || !strings.Contains(err.Error(), table) {
|
|
t.Fatalf("expected refusal naming %s, got %v", table, err)
|
|
}
|
|
assertResetRows(t, db, table, 1)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestResetBackupAndRollback(t *testing.T) {
|
|
for _, failDelete := range []bool{false, true} {
|
|
t.Run(map[bool]string{false: "reset", true: "rollback"}[failDelete], func(t *testing.T) {
|
|
path, db := resetFixture(t)
|
|
t.Setenv("QFS_BACKUP_DISABLE", "1")
|
|
if err := db.Exec("INSERT INTO local_projects (sync_status) VALUES ('pending')").Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if failDelete {
|
|
if err := db.Exec("CREATE TRIGGER block_reset BEFORE DELETE ON local_configurations BEGIN SELECT RAISE(ABORT, 'blocked'); END").Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := db.Exec("INSERT INTO local_configurations (sync_status) VALUES ('pending')").Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
cfg := filepath.Join(filepath.Dir(path), "config.yaml")
|
|
if err := os.WriteFile(cfg, []byte("server: {}"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
err := ResetDataWithOptions(path, cfg, true)
|
|
if (err != nil) != failDelete {
|
|
t.Fatalf("reset: %v", err)
|
|
}
|
|
want := int64(0)
|
|
if failDelete {
|
|
want = 1
|
|
}
|
|
assertResetRows(t, db, "local_projects", want)
|
|
archives, err := filepath.Glob(filepath.Join(filepath.Dir(path), "backups", "pre-reset", "*.zip"))
|
|
if err != nil || len(archives) != 1 {
|
|
t.Fatalf("archives=%v err=%v", archives, err)
|
|
}
|
|
archive, err := zip.OpenReader(archives[0])
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer archive.Close()
|
|
for _, entry := range archive.File {
|
|
if entry.Name != filepath.Base(path) {
|
|
continue
|
|
}
|
|
in, err := entry.Open()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
data, err := io.ReadAll(in)
|
|
in.Close()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
restoredPath := filepath.Join(t.TempDir(), "restored.db")
|
|
if err := os.WriteFile(restoredPath, data, 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
restored, err := gorm.Open(sqlite.Open(restoredPath), &gorm.Config{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sqlDB, _ := restored.DB()
|
|
defer sqlDB.Close()
|
|
assertResetRows(t, restored, "local_projects", 1)
|
|
}
|
|
assertResetRows(t, db, "connection_settings", 1)
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestResetRefusesFailedBackup(t *testing.T) {
|
|
path, db := resetFixture(t)
|
|
if err := db.Exec("INSERT INTO local_projects (sync_status) VALUES ('synced')").Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Setenv("QFS_BACKUP_DIR", path) // A database file cannot be a backup directory.
|
|
if err := ResetDataWithOptions(path, "", true); err == nil {
|
|
t.Fatal("expected backup refusal")
|
|
}
|
|
assertResetRows(t, db, "local_projects", 1)
|
|
}
|
|
|
|
func TestResetLegacySchema(t *testing.T) {
|
|
path, db := resetFixture(t)
|
|
if err := db.Exec("ALTER TABLE local_projects DROP COLUMN sync_status").Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := ResetDataWithOptions(path, "", false); err == nil {
|
|
t.Fatal("expected legacy-state refusal")
|
|
}
|
|
if err := ResetDataWithOptions(path, "", true); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
|
|
func resetFixture(t *testing.T) (string, *gorm.DB) {
|
|
t.Helper()
|
|
t.Setenv("QFS_BACKUP_DIR", "")
|
|
path := filepath.Join(t.TempDir(), "qfs.db")
|
|
db, err := gorm.Open(sqlite.Open(path), &gorm.Config{})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
sqlDB, _ := db.DB()
|
|
t.Cleanup(func() { sqlDB.Close() })
|
|
for _, table := range []string{"pending_changes", "local_projects", "local_configurations", "connection_settings"} {
|
|
if err := db.Exec("CREATE TABLE " + table + " (id INTEGER PRIMARY KEY, sync_status TEXT)").Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
if err := db.Exec("INSERT INTO connection_settings (sync_status) VALUES ('synced')").Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return path, db
|
|
}
|
|
|
|
func assertResetRows(t *testing.T, db *gorm.DB, table string, want int64) {
|
|
t.Helper()
|
|
var count int64
|
|
if err := db.Table(table).Count(&count).Error; err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if count != want {
|
|
t.Fatalf("%s has %d rows, want %d", table, count, want)
|
|
}
|
|
}
|