Skip to content

One self-hosted app for your shows, movies and music.

7.7 KB
Raw Blame
package database

import (
	"errors"
	"os"
	"path/filepath"
	"strings"
	"testing"
	"testing/fstest"
)

var (
	v1 = fstest.MapFS{"0001_a.sql": {Data: []byte("CREATE TABLE a(x);")}}
	v2 = fstest.MapFS{
		"0001_a.sql": {Data: []byte("CREATE TABLE a(x);")},
		"0002_b.sql": {Data: []byte("CREATE TABLE b(y);")},
	}
)

func openAt(t *testing.T, dir string, ms fstest.MapFS) (*Store, error) {
	t.Helper()
	s, err := Open(dir, Options{MainMigrations: ms})
	if err == nil {
		t.Cleanup(func() { _ = s.Close() })
	}
	return s, err
}

func TestNewerDataIsRefused(t *testing.T) {
	dir := t.TempDir()
	s, err := openAt(t, dir, v2)
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	_, err = openAt(t, dir, v1)
	var nd *NewerDataError
	if !errors.As(err, &nd) || nd.Have != 2 || nd.Know != 1 {
		t.Fatalf("got %v", err)
	}
	if !strings.Contains(err.Error(), "this data is from a newer HolyArrs (schema 2, this build knows 1)") {
		t.Fatalf("message %q", err)
	}
}

func TestPreUpdateBackupIsCheckedAndNamed(t *testing.T) {
	dir := t.TempDir()
	s, err := openAt(t, dir, v1)
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	backups := filepath.Join(dir, "backups")
	_ = os.MkdirAll(backups, 0o750)
	stale := filepath.Join(backups, "main-pre-update-0001-to-0002-old.db.partial")
	_ = os.WriteFile(stale, []byte("half"), 0o600)
	if _, err := openAt(t, dir, v2); err != nil {
		t.Fatal(err)
	}
	if _, err := os.Stat(stale); !os.IsNotExist(err) {
		t.Fatal("stale .partial left behind")
	}
	got, _ := filepath.Glob(filepath.Join(backups, "main-pre-update-0001-to-0002-*.db"))
	if len(got) != 1 {
		t.Fatalf("backups %v", got)
	}
	sum, err := os.ReadFile(got[0] + ".sha256")
	want, _ := fileSHA256(got[0])
	if err != nil || !strings.HasPrefix(string(sum), want) {
		t.Fatalf("sha256 file %q %v, want %s", sum, err, want)
	}
}

func TestUpdateRefusedWithoutSpace(t *testing.T) {
	dir := t.TempDir()
	s, err := openAt(t, dir, v1)
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	old := freeSpace
	freeSpace = func(string) (uint64, error) { return 100 << 20, nil }
	defer func() { freeSpace = old }()
	_, err = openAt(t, dir, v2)
	if !errors.Is(err, ErrNoSpace) || !strings.Contains(err.Error(), "need ") || !strings.Contains(err.Error(), "have 100.0 MB") {
		t.Fatalf("got %v", err)
	}
}

func TestUpdateRefusedAfterThreeFailedBackups(t *testing.T) {
	dir := t.TempDir()
	s, err := openAt(t, dir, v1)
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	old, tries := takeBackup, 0
	takeBackup = func(*writer, string, string, int, int) (string, error) {
		tries++
		return "", errors.New("disk said no")
	}
	defer func() { takeBackup = old }()
	_, err = openAt(t, dir, v2)
	if !errors.Is(err, ErrBackup) || tries != 3 {
		t.Fatalf("got %v after %d tries", err, tries)
	}
	takeBackup = old
	s, err = openAt(t, dir, v1)
	if err != nil {
		t.Fatalf("data changed after the refused update: %v", err)
	}
	if v, _ := s.Version(); v != 1 {
		t.Fatalf("version %d, want 1", v)
	}
}

func TestHumanSize(t *testing.T) {
	for n, want := range map[uint64]string{12: "12 B", 200 << 20: "200.0 MB", 3 << 29: "1.5 GB"} {
		if got := humanSize(n); got != want {
			t.Fatalf("%d: %s, want %s", n, got, want)
		}
	}
}

// tinyDisk makes every disk report one byte free.
func tinyDisk(t *testing.T) {
	old := freeSpace
	freeSpace = func(string) (uint64, error) { return 1, nil }
	t.Cleanup(func() { freeSpace = old })
}

func preUpdateCopies(t *testing.T, dir string) []string {
	t.Helper()
	got, _ := filepath.Glob(filepath.Join(dir, "backups", "*-pre-update-*.db"))
	return got
}

// Scenario 1: a fresh install makes no backup and never checks space.
func TestFreshInstallSkipsBackupAndSpace(t *testing.T) {
	tinyDisk(t)
	dir := t.TempDir()
	called := false
	s, err := Open(dir, Options{MainMigrations: v2, OnUpdating: func() { called = true }})
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	if n := preUpdateCopies(t, dir); len(n) != 0 || called {
		t.Fatalf("copies %v, updating %v", n, called)
	}
}

// Scenario 2: a restart with nothing to migrate makes no backup and starts
// on a nearly full disk.
func TestRestartWithoutMigrationSkipsBackupAndSpace(t *testing.T) {
	dir := t.TempDir()
	s, err := openAt(t, dir, v2)
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	tinyDisk(t)
	called := false
	s, err = Open(dir, Options{MainMigrations: v2, OnUpdating: func() { called = true }})
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	if n := preUpdateCopies(t, dir); len(n) != 0 || called {
		t.Fatalf("copies %v, updating %v", n, called)
	}
}

// Scenario 5: a measured shortage refuses and leaves the data byte for
// byte; HOLYARRS_SKIP_SPACE_CHECK=yes lets the update run.
func TestShortDiskRefusesThenSkipEnvRuns(t *testing.T) {
	dir := t.TempDir()
	s, err := openAt(t, dir, v1)
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	before, _ := os.ReadFile(filepath.Join(dir, MainFile))
	tinyDisk(t)
	if _, err := openAt(t, dir, v2); !errors.Is(err, ErrNoSpace) {
		t.Fatalf("got %v", err)
	}
	after, _ := os.ReadFile(filepath.Join(dir, MainFile))
	if string(before) != string(after) {
		t.Fatal("the database changed after a refused update")
	}
	t.Setenv(SkipSpaceCheckEnv, "yes")
	s, err = openAt(t, dir, v2)
	if err != nil {
		t.Fatal(err)
	}
	if v, _ := s.Version(); v != 2 {
		t.Fatalf("version %d", v)
	}
}

// Scenario 6: free space that cannot be measured only warns.
func TestUnmeasurableSpaceWarnsAndUpdates(t *testing.T) {
	for _, hook := range []string{"freeSpace", "sameVolume"} {
		t.Run(hook, func(t *testing.T) {
			dir := t.TempDir()
			s, err := openAt(t, dir, v1)
			if err != nil {
				t.Fatal(err)
			}
			_ = s.Close()
			oldF, oldS := freeSpace, sameVolume
			defer func() { freeSpace, sameVolume = oldF, oldS }()
			if hook == "freeSpace" {
				freeSpace = func(string) (uint64, error) { return 0, errors.New("not supported") }
			} else {
				sameVolume = func(string, string) (bool, error) { return false, errors.New("not supported") }
			}
			s, err = openAt(t, dir, v2)
			if err != nil {
				t.Fatal(err)
			}
			if v, _ := s.Version(); v != 2 {
				t.Fatalf("version %d", v)
			}
		})
	}
}

// Scenario 7: a migration that fails half way is undone; the pre-update
// copy is there and the error is one a person is shown.
func TestFailedMigrationIsUndone(t *testing.T) {
	dir := t.TempDir()
	s, err := openAt(t, dir, v1)
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	bad := fstest.MapFS{
		"0001_a.sql": v2["0001_a.sql"],
		"0002_b.sql": {Data: []byte("CREATE TABLE b(y); INSERT INTO nope VALUES (1);")},
	}
	updating := false
	_, err = Open(dir, Options{MainMigrations: bad, OnUpdating: func() { updating = true }})
	if !errors.Is(err, ErrMigration) || !updating {
		t.Fatalf("got %v (updating %v)", err, updating)
	}
	if n := preUpdateCopies(t, dir); len(n) != 1 {
		t.Fatalf("copies %v", n)
	}
	s, err = openAt(t, dir, v1)
	if err != nil {
		t.Fatal(err)
	}
	if v, _ := s.Version(); v != 1 {
		t.Fatalf("version %d", v)
	}
	var n int
	if err := s.main.db.QueryRow("SELECT count(*) FROM sqlite_master WHERE name='b'").Scan(&n); err != nil || n != 0 {
		t.Fatalf("table b left behind: %d %v", n, err)
	}
}

// Scenario 12: a backups folder that cannot be made refuses with a clear
// error and leaves the data alone.
func TestUnwritableBackupFolderRefuses(t *testing.T) {
	dir := t.TempDir()
	s, err := openAt(t, dir, v1)
	if err != nil {
		t.Fatal(err)
	}
	_ = s.Close()
	if err := os.WriteFile(filepath.Join(dir, "backups"), []byte("not a folder"), 0o600); err != nil {
		t.Fatal(err)
	}
	_, err = openAt(t, dir, v2)
	if !errors.Is(err, ErrBackup) || !strings.Contains(err.Error(), "backups folder") || !strings.Contains(err.Error(), "not changed") {
		t.Fatalf("got %v", err)
	}
	_ = os.Remove(filepath.Join(dir, "backups"))
	s, err = openAt(t, dir, v1)
	if err != nil {
		t.Fatal(err)
	}
	if v, _ := s.Version(); v != 1 {
		t.Fatalf("version %d", v)
	}
}