vaultik/internal/vaultik/storage_bind_test.go

package vaultik_test

import (
	"context"
	"path/filepath"
	"testing"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"sneak.berlin/go/vaultik/internal/config"
	"sneak.berlin/go/vaultik/internal/database"
	"sneak.berlin/go/vaultik/internal/log"
	"sneak.berlin/go/vaultik/internal/storage"
	"sneak.berlin/go/vaultik/internal/storage/faultstore"
	"sneak.berlin/go/vaultik/internal/vaultik"
)

// storageBindingOf returns the destination the local index is bound to,
// or "" when it is not bound.
func storageBindingOf(
	ctx context.Context, t *testing.T, repos *database.Repositories,
) string {
	t.Helper()

	got, err := repos.LocalMeta.Get(ctx, database.LocalMetaKeyStorageURL)
	require.NoError(t, err)

	return got
}

// TestFailedFirstBackupLeavesIndexUnbound checks that a first backup
// the destination refuses, as a mistyped bucket would, leaves the local
// index unbound, so a backup with the corrected destination succeeds.
func TestFailedFirstBackupLeavesIndexUnbound(t *testing.T) {
	log.Initialize(log.Config{})
	t.Parallel()

	ctx := context.Background()
	storeDir := t.TempDir()
	v, repos := newFileDestinationVaultik(ctx, t, storeDir)
	working := v.Storage

	refusing := faultstore.New(working)
	refusing.OnPut = func(string) faultstore.PutAction { return faultstore.PutFail }
	refusing.OnStat = func(string) bool { return true }
	v.Storage = refusing
	v.Config.StorageURL = "file://" + filepath.Join(t.TempDir(), "typo")

	require.ErrorIs(t, backUp(v, "first"), faultstore.ErrInjectedUpload)
	assert.Empty(t, storageBindingOf(ctx, t, repos))

	v.Storage = working
	v.Config.StorageURL = "file://" + storeDir

	require.NoError(t, backUp(v, "first"))
	assert.Equal(t, "file://"+storeDir, storageBindingOf(ctx, t, repos))
}

// TestBackupToOtherDestinationWritesNoMarker checks that a backup
// refuses a local index bound to a different destination before it
// writes the marker to the configured one.
func TestBackupToOtherDestinationWritesNoMarker(t *testing.T) {
	log.Initialize(log.Config{})
	t.Parallel()

	ctx := context.Background()
	firstDir := t.TempDir()
	v, _ := newFileDestinationVaultik(ctx, t, firstDir)
	v.Config.StorageURL = "file://" + firstDir

	require.NoError(t, backUp(v, "first"))

	secondDir := t.TempDir()
	secondStore, err := storage.NewFileStorer(secondDir)
	require.NoError(t, err)

	v.Storage = secondStore
	v.Config.StorageURL = "file://" + secondDir

	require.ErrorContains(t, backUp(v, "first"),
		"local index is bound to a different backup destination")
	assert.NoFileExists(t, filepath.Join(secondDir, markerFile))
}

// TestCommandsOtherThanBackupLeaveIndexUnbound checks that commands
// other than a backup do not bind an unbound local index, whether or not
// they fail. Each runs on a fresh local index.
func TestCommandsOtherThanBackupLeaveIndexUnbound(t *testing.T) {
	log.Initialize(log.Config{})
	t.Parallel()

	tests := []struct {
		name string
		run  func(v *vaultik.Vaultik) error
	}{
		{"prune", func(v *vaultik.Vaultik) error {
			return v.Prune(&vaultik.PruneOptions{Force: true})
		}},
		{"snapshot purge", func(v *vaultik.Vaultik) error {
			return v.PurgeSnapshotsWithOptions(
				&vaultik.SnapshotPurgeOptions{KeepLatest: true, Force: true})
		}},
		{"snapshot remove", func(v *vaultik.Vaultik) error {
			_, err := v.RemoveSnapshot("host_first_2026-01-02T03:04:05Z",
				&vaultik.RemoveOptions{Force: true})

			return err
		}},
		{"snapshot remove --all", func(v *vaultik.Vaultik) error {
			_, err := v.RemoveAllSnapshots(&vaultik.RemoveOptions{Force: true})

			return err
		}},
		{"remote nuke", func(v *vaultik.Vaultik) error {
			return v.NukeRemote(true)
		}},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			ctx := context.Background()
			v, repos := newFileDestinationVaultik(ctx, t, t.TempDir())

			_ = tt.run(v)

			assert.Empty(t, storageBindingOf(ctx, t, repos))
		})
	}
}

// buildBindTestVaultik returns a minimal Vaultik wired with a real
// in-memory DB and a config carrying the given StorageURL. Enough to
// exercise EnsureStorageBinding without spinning up storage or fx.
func buildBindTestVaultik(
	t *testing.T, storageURL string,
) (*vaultik.TestVaultik, *database.Repositories) {
	t.Helper()

	db, err := database.NewTestDB()
	require.NoError(t, err)
	t.Cleanup(func() { _ = db.Close() })

	repos := database.NewRepositories(db)

	tv := vaultik.NewForTesting(nil)
	tv.Repositories = repos
	tv.DB = db
	tv.Config = &config.Config{StorageURL: storageURL}
	tv.SetContext(context.Background())

	return tv, repos
}

func TestEnsureStorageBinding_FreshDBRecordsURL(t *testing.T) {
	log.Initialize(log.Config{})
	t.Parallel()

	tv, repos := buildBindTestVaultik(t, "file:///mnt/backups/new")

	require.NoError(t, tv.EnsureStorageBinding())

	got, err := repos.LocalMeta.Get(context.Background(), database.LocalMetaKeyStorageURL)
	require.NoError(t, err)
	assert.Equal(t, "file:///mnt/backups/new", got,
		"first call must record the configured URL")
}

func TestEnsureStorageBinding_MatchingURLPasses(t *testing.T) {
	log.Initialize(log.Config{})
	t.Parallel()

	tv, repos := buildBindTestVaultik(t, "s3://bucket/prefix")

	require.NoError(t, repos.LocalMeta.Set(context.Background(),
		database.LocalMetaKeyStorageURL, "s3://bucket/prefix"))

	require.NoError(t, tv.EnsureStorageBinding())
}

func TestEnsureStorageBinding_MismatchRefuses(t *testing.T) {
	log.Initialize(log.Config{})
	t.Parallel()

	tv, repos := buildBindTestVaultik(t, "file:///mnt/backups/new")

	require.NoError(t, repos.LocalMeta.Set(context.Background(),
		database.LocalMetaKeyStorageURL, "file:///mnt/backups/old"))

	err := tv.EnsureStorageBinding()
	require.Error(t, err)
	assert.Contains(t, err.Error(), "file:///mnt/backups/old")
	assert.Contains(t, err.Error(), "file:///mnt/backups/new")
	assert.Contains(t, err.Error(), "vaultik database delete")
}

// A config with no storage_url names its destination with s3.endpoint,
// s3.bucket and s3.prefix; a change to any of them must be refused just
// as a changed storage_url is.
func TestEnsureStorageBinding_S3FieldsChangeRefuses(t *testing.T) {
	log.Initialize(log.Config{})
	t.Parallel()

	bound := config.S3Config{
		Endpoint: "https://s3.example.com",
		Bucket:   "bucket-a",
		Prefix:   "backups",
	}

	tests := []struct {
		name    string
		changed config.S3Config
	}{
		{"bucket", config.S3Config{
			Endpoint: bound.Endpoint, Bucket: "bucket-b", Prefix: bound.Prefix,
		}},
		{"prefix", config.S3Config{
			Endpoint: bound.Endpoint, Bucket: bound.Bucket, Prefix: "other",
		}},
		{"endpoint", config.S3Config{
			Endpoint: "https://s3.other.com", Bucket: bound.Bucket, Prefix: bound.Prefix,
		}},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			tv, _ := buildBindTestVaultik(t, "")

			tv.Config.S3 = bound
			require.NoError(t, tv.EnsureStorageBinding(), "first use binds")
			require.NoError(t, tv.EnsureStorageBinding(), "same destination passes")

			tv.Config.S3 = tt.changed
			err := tv.EnsureStorageBinding()
			require.Error(t, err)
			assert.Contains(t, err.Error(),
				"local index is bound to a different backup destination")
			assert.Contains(t, err.Error(), "vaultik database delete")
		})
	}
}