Make remote nuke delete leftover .partial uploads (closes #281)

Every listing skips an object whose name ends in `.partial`, the
temporary name a `file://` or rclone upload writes before moving the
object into place. `remote nuke` deletes only what the listings return,
so it left the `.partial` objects killed uploads leave behind and still
reported the destination store empty.

Storer gains DeletePartialUploads. The file and rclone backends remove
every `.partial` object under the prefix; S3 has none to remove, since
it shows an object only once its upload completes. `remote nuke` calls
it for `metadata/` and `blobs/` as its last step.

Empty directories under a `file://` destination are still left behind.

Model: opus-5-5

TODO.md

@@ -22,38 +22,12 @@ the tag exists and is exercised; what is left is merging `next` to
 
 # Completed Steps
 
-- 2026-10-08: Made a backup cancelled under `--skip-errors` stop at once
-  ([issue #286](https://git.eeqj.de/sneak/vaultik/issues/286)). After
-  Ctrl-C or SIGTERM, phase 2 treated the cancellation error from each
-  remaining file like an unreadable file: it opened the file, printed an
-  error line for it, counted it as failed and went on to the next one.
-  The run now stops at the first file after the cancellation, and no
-  file is counted as failed because of it.
-
 - 2026-10-08: Made `remote nuke` delete the `.partial` files that
   uploads cut off part-way leave on the destination store
-  ([issue #281](https://git.eeqj.de/sneak/vaultik/issues/281)). The
+  ([issue #281](https://git.eeqj.de/sneak/vaultik/issues/281)). Every
-  file and rclone listings skip such a file, so the command left it in
+  listing skips such a file, so the command left it in place and still
-  place and still reported the store empty. It now removes them under
+  reported the store empty. It now removes them under `metadata/` and
-  `metadata/` and `blobs/` as its last step.
+  `blobs/` as its last step.
-
-- 2026-10-08: Made a local index error while recording a directory or
-  symlink stop a backup under `--skip-errors`
-  ([issue #284](https://git.eeqj.de/sneak/vaultik/issues/284)). Phase 2
-  only records such an entry in the local index, since it has no data
-  to open or read, but an error doing so was skipped like an unreadable
-  file. The snapshot then completed without the entry, and a restore
-  did not recreate it. The error now stops the backup, as it does
-  without the flag.
-
-- 2026-10-08: Counted a file that a backup could not store as failed
-  ([issue #280](https://git.eeqj.de/sneak/vaultik/issues/280)). A file
-  that phase 1 counted and phase 2 could not open, because it was
-  unreadable under `--skip-errors` or removed in between, was reported
-  in the summary as unchanged with its bytes as backed up, and the
-  `snapshots` row's `file_count` and `total_size` included it. The
-  summary now counts it as failed, and its data total and the row leave
-  it out.
 
 - 2026-10-08: Made `remote info` report a snapshot's blob count and
   blob size as unknown when its manifest cannot be read

internal/snapshot/scanner.go

@@ -133,13 +133,10 @@ type ScannerConfig struct {
 
 // ScanResult contains the results of a scan operation. Files and bytes
 // are counted per file: BytesScanned is the size of the new and changed
-// files, BytesSkipped that of the unchanged ones. FilesFailed counts the
+// files, BytesSkipped that of the unchanged ones.
-// new and changed files that phase 2 could not store; FilesScanned
-// includes them and BytesScanned does not.
 type ScanResult struct {
 	FilesScanned   int
 	FilesSkipped   int
-	FilesFailed    int
 	FilesDeleted   int
 	BytesScanned   int64
 	BytesSkipped   int64
@@ -1312,13 +1309,6 @@ func (s *Scanner) processPhase(
 
 	// Process each file
 	for _, fileToProcess := range filesToProcess {
-		// Check context cancellation
-		select {
-		case <-ctx.Done():
-			return ctx.Err()
-		default:
-		}
-
 		// Update progress
 		if s.progress != nil {
 			s.progress.GetStats().CurrentFile.Store(fileToProcess.Path)
@@ -1355,32 +1345,13 @@ func (s *Scanner) processPhase(
 	return s.finalizeProcessPhase(ctx, result)
 }
 
-// processFileWithErrorHandling records a directory or symlink, or wraps
+// processFileWithErrorHandling wraps processFileStreaming with error recovery for
-// processFileStreaming for a regular file with error recovery for deleted
+// deleted files and skip-errors mode. Returns (skipped, error).
-// files and skip-errors mode. Returns (skipped, error).
 func (s *Scanner) processFileWithErrorHandling(
 	ctx context.Context, fileToProcess *FileToProcess, result *ScanResult,
 ) (bool, error) {
-	// A directory or symlink has no data to open or read; it is only
-	// recorded in the local index. An error recording it stops the run
-	// even under --skip-errors, or the snapshot would complete without it.
-	mode := os.FileMode(fileToProcess.File.Mode)
-	if mode&os.ModeSymlink != 0 || mode.IsDir() {
-		err := s.recordNonRegularFile(ctx, fileToProcess)
-		if err != nil {
-			return false, fmt.Errorf("processing file %s: %w", fileToProcess.Path, err)
-		}
-
-		return false, nil
-	}
-
 	err := s.processFileStreaming(ctx, fileToProcess, result)
 	if err != nil {
-		// A cancelled run stops here even under --skip-errors, rather than
-		// counting this file as failed and going on to the next one.
-		if ctx.Err() != nil {
-			return false, fmt.Errorf("processing file %s: %w", fileToProcess.Path, err)
-		}
 		// A packer/database/encryption/upload failure means the chunk's data
 		// may not have been stored. Skipping the file would let the snapshot
 		// record a file whose chunk is in no blob and cannot be restored, so
@@ -1394,7 +1365,7 @@ func (s *Scanner) processFileWithErrorHandling(
 			log.Warn("File was deleted during backup, skipping",
 				"path", fileToProcess.Path)
 
-			countFailedFile(fileToProcess, result)
+			result.FilesSkipped++
 
 			return true, nil
 		}
@@ -1405,7 +1376,7 @@ func (s *Scanner) processFileWithErrorHandling(
 			s.ui.Errorf("Failed to process %s: %v. Skipping (--skip-errors).",
 				s.ui.Path(fileToProcess.Path), err)
 
-			countFailedFile(fileToProcess, result)
+			result.FilesSkipped++
 
 			return true, nil
 		}
@@ -1416,13 +1387,6 @@ func (s *Scanner) processFileWithErrorHandling(
 	return false, nil
 }
 
-// countFailedFile counts a file that phase 2 could not store as failed
-// and takes its size back out of BytesScanned, where phase 1 put it.
-func countFailedFile(fileToProcess *FileToProcess, result *ScanResult) {
-	result.FilesFailed++
-	result.BytesScanned -= fileToProcess.FileInfo.Size()
-}
-
 // printProcessingProgress prints a periodic progress line during the process phase,
 // showing files processed, bytes transferred, throughput, and ETA
 func (s *Scanner) printProcessingProgress(
@@ -1791,11 +1755,16 @@ func (e *packerError) Error() string { return e.err.Error() }
 
 func (e *packerError) Unwrap() error { return e.err }
 
-// processFileStreaming processes a regular file by streaming chunks directly
+// processFileStreaming processes a file by streaming chunks directly to the packer
-// to the packer
 func (s *Scanner) processFileStreaming(
 	ctx context.Context, fileToProcess *FileToProcess, result *ScanResult,
 ) error {
+	// Symlinks and directories have no data to chunk — just record them in the DB.
+	mode := os.FileMode(fileToProcess.File.Mode)
+	if mode&os.ModeSymlink != 0 || mode.IsDir() {
+		return s.recordNonRegularFile(ctx, fileToProcess)
+	}
+
 	file, err := s.fs.Open(fileToProcess.Path)
 	if err != nil {
 		return fmt.Errorf("opening file: %w", wrapPermissionError(fileToProcess.Path, err))

internal/snapshot/skip_errors_test.go

@@ -82,32 +82,6 @@ func (f *readFailFs) Open(name string) (afero.File, error) {
 	return file, nil
 }
 
-// cancelOnOpenFs cancels the run when the scanner opens the target file to
-// back it up, as Ctrl-C partway through processing would, and records each
-// file opened after that.
-type cancelOnOpenFs struct {
-	afero.Fs
-
-	target            string
-	cancel            context.CancelFunc
-	cancelled         bool
-	openedAfterCancel []string
-}
-
-//nolint:ireturn // afero.Fs.Open is defined to return the interface.
-func (f *cancelOnOpenFs) Open(name string) (afero.File, error) {
-	if f.cancelled {
-		f.openedAfterCancel = append(f.openedAfterCancel, name)
-	}
-
-	if name == f.target {
-		f.cancel()
-		f.cancelled = true
-	}
-
-	return f.Fs.Open(name)
-}
-
 // linkRemovedAfterLstatFs is the real filesystem, except that the symlink at
 // target is removed right after the walk lstats it, as happens when a link is
 // deleted during a backup. The scanner's readlink of it then fails.
@@ -154,16 +128,15 @@ func writeSkipErrorTestFile(t *testing.T, fs afero.Fs, path, content string) {
 	}
 }
 
-// runSkipErrorScan scans source on fs under ctx with the given skip-errors
+// runSkipErrorScan scans source on fs with the given skip-errors setting,
-// setting, printing user-facing messages to uiw (nil discards them), and
+// printing user-facing messages to uiw (nil discards them), and returns the
-// returns the repositories (for inspection) and the scan error.
+// repositories (for inspection) and the scan error.
 func runSkipErrorScan(
-	ctx context.Context, t *testing.T, fs afero.Fs, source string,
+	t *testing.T, fs afero.Fs, source string, skipErrors bool, uiw *ui.Writer,
-	skipErrors bool, uiw *ui.Writer,
 ) (*database.Repositories, error) {
 	t.Helper()
 
-	db, err := database.New(ctx, ":memory:")
+	db, err := database.NewTestDB()
 	if err != nil {
 		t.Fatalf("create test db: %v", err)
 	}
@@ -188,6 +161,7 @@ func runSkipErrorScan(
 		SkipErrors:       skipErrors,
 	})
 
+	ctx := context.Background()
 	snapshotID := "test-snapshot-skip-errors"
 	createTestSnapshotRecord(ctx, t, repos, snapshotID)
 
@@ -211,7 +185,7 @@ func TestScannerPackingFailureAbortsUnderSkipErrors(t *testing.T) {
 	writeSkipErrorTestFile(t, fs, "/source/file1.txt", "first file content")
 	writeSkipErrorTestFile(t, fs, "/source/file2.txt", "second file content")
 
-	repos, err := runSkipErrorScan(context.Background(), t, fs, "/source", true, nil)
+	repos, err := runSkipErrorScan(t, fs, "/source", true, nil)
 	if err == nil {
 		t.Fatal("expected scan to abort on the packer error, got nil")
 	}
@@ -238,7 +212,7 @@ func TestScannerReadErrorAbortsWithoutSkipErrors(t *testing.T) {
 	fs := &readFailFs{Fs: afero.NewMemMapFs(), target: target}
 	writeSkipErrorTestFile(t, fs, target, "content that cannot be read")
 
-	_, err := runSkipErrorScan(context.Background(), t, fs, "/source", false, nil)
+	_, err := runSkipErrorScan(t, fs, "/source", false, nil)
 	if err == nil {
 		t.Fatal("expected scan to fail on the read error, got nil")
 	}
@@ -254,7 +228,7 @@ func TestScannerReadErrorSkippedWithSkipErrors(t *testing.T) {
 	fs := &readFailFs{Fs: afero.NewMemMapFs(), target: target}
 	writeSkipErrorTestFile(t, fs, target, "content that cannot be read")
 
-	repos, err := runSkipErrorScan(context.Background(), t, fs, "/source", true, nil)
+	repos, err := runSkipErrorScan(t, fs, "/source", true, nil)
 	if err != nil {
 		t.Fatalf("expected scan to complete with --skip-errors, got %v", err)
 	}
@@ -293,7 +267,7 @@ func TestScannerUnreadableSymlinkAbortsWithoutSkipErrors(t *testing.T) {
 	sourceDir, linkPath := writeSymlinkSource(t)
 	fs := &linkRemovedAfterLstatFs{t: t, target: linkPath}
 
-	_, err := runSkipErrorScan(context.Background(), t, fs, sourceDir, false, nil)
+	_, err := runSkipErrorScan(t, fs, sourceDir, false, nil)
 	if !errors.Is(err, os.ErrNotExist) {
 		t.Fatalf("expected scan to fail on the removed symlink, got %v", err)
 	}
@@ -309,7 +283,7 @@ func TestScannerUnreadableSymlinkSkippedWithSkipErrors(t *testing.T) {
 	fs := &linkRemovedAfterLstatFs{t: t, target: linkPath}
 	uiw := ui.NewWithColor(io.Discard, false)
 
-	repos, err := runSkipErrorScan(context.Background(), t, fs, sourceDir, true, uiw)
+	repos, err := runSkipErrorScan(t, fs, sourceDir, true, uiw)
 	if err != nil {
 		t.Fatalf("expected scan to complete with --skip-errors, got %v", err)
 	}
@@ -328,56 +302,3 @@ func TestScannerUnreadableSymlinkSkippedWithSkipErrors(t *testing.T) {
 		t.Fatalf("expected %s not to be recorded", linkPath)
 	}
 }
-
-// TestScannerCancelStopsSkipErrorsRun checks that a --skip-errors backup
-// cancelled partway through processing returns the cancellation error,
-// opens no further file, and reports no file as failed.
-func TestScannerCancelStopsSkipErrorsRun(t *testing.T) {
-	t.Parallel()
-
-	tests := []struct {
-		name          string
-		targetContent string
-	}{
-		// The cancellation lands while the target is being read.
-		{name: "while reading a file", targetContent: "first file content"},
-		// An empty target has no chunks, so the cancellation goes unnoticed
-		// until the run moves on to the next file.
-		{name: "between files", targetContent: ""},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			const target = "/source/a.txt"
-
-			ctx, cancel := context.WithCancel(context.Background())
-			defer cancel()
-
-			fs := &cancelOnOpenFs{
-				Fs: afero.NewMemMapFs(), target: target, cancel: cancel,
-			}
-			writeSkipErrorTestFile(t, fs, target, tt.targetContent)
-			writeSkipErrorTestFile(t, fs, "/source/b.txt", "second file content")
-			writeSkipErrorTestFile(t, fs, "/source/c.txt", "third file content")
-
-			uiw := ui.NewWithColor(io.Discard, false)
-
-			_, err := runSkipErrorScan(ctx, t, fs, "/source", true, uiw)
-			if !errors.Is(err, context.Canceled) {
-				t.Fatalf("expected the cancellation error, got %v", err)
-			}
-
-			if len(fs.openedAfterCancel) != 0 {
-				t.Fatalf("expected no file opened after the cancellation, got %v",
-					fs.openedAfterCancel)
-			}
-
-			if uiw.ErrorCount() != 0 {
-				t.Fatalf("expected no file reported as failed, got %d error lines",
-					uiw.ErrorCount())
-			}
-		})
-	}
-}

internal/snapshot/snapshot.go

@@ -892,7 +892,7 @@ func (sm *SnapshotManager) getFileSize(path string) int64 {
 // BackupStats contains statistics from a backup operation
 type BackupStats struct {
 	FilesScanned  int
-	TotalSize     int64 // Total size of the files in the snapshot
+	TotalSize     int64 // Total size of all files examined
 	ChunksCreated int
 	BlobsCreated  int
 	BytesUploaded int64

internal/storage/file.go

@@ -272,7 +272,7 @@ func (f *FileStorer) DeletePartialUploads(ctx context.Context, prefix string) er
 		return f.fs.Remove(path)
 	})
 	if err != nil {
-		return fmt.Errorf("walking directory: %w", err)
+		return fmt.Errorf("deleting partial uploads: %w", err)
 	}
 
 	return nil

internal/storage/storer.go

@@ -73,8 +73,7 @@ type Storer interface {
 
 	// DeletePartialUploads removes every object under prefix that an
 	// upload cut off part-way left under a temporary name ending in
-	// `.partial`. The file and rclone backends' List and ListStream skip
+	// `.partial`. List and ListStream never return such an object.
-	// such an object.
 	DeletePartialUploads(ctx context.Context, prefix string) error
 
 	// Info returns human-readable storage location information.

internal/vaultik/nuke_remote_test.go

@@ -10,44 +10,30 @@ import (
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
 	"sneak.berlin/go/vaultik/internal/log"
-	"sneak.berlin/go/vaultik/internal/snapshot"
 )
 
 // TestNukeRemoteLeavesNoFiles checks that remote nuke leaves no file
-// under a file:// destination, including the `.partial` files uploads
+// under a file:// destination, including the `.partial` file an upload
-// killed part-way leave next to a snapshot's metadata and next to where a
+// killed part-way leaves next to where its blob would have been.
-// blob would have been.
 func TestNukeRemoteLeavesNoFiles(t *testing.T) {
 	log.Initialize(log.Config{})
 	t.Parallel()
 
 	ctx := context.Background()
 	storeDir := filepath.Join(t.TempDir(), "store")
-	v, repos, _ := backUpToFileDestination(ctx, t, storeDir)
+	v, _, _ := backUpToFileDestination(ctx, t, storeDir)
 
-	snapshots, err := repos.Snapshots.ListRecent(ctx, listRecentTestLimit)
-	require.NoError(t, err)
-	require.Len(t, snapshots, 1)
-
-	snapshotKey := snapshot.RemoteSnapshotKey(snapshots[0].ID.String())
 	hash := testBlobHashA
-	leftovers := []string{
+	leftover := filepath.Join(storeDir, "blobs", hash[:2], hash[2:4],
-		filepath.Join(storeDir, "metadata", snapshotKey,
+		hash+"-123456.partial")
-			"db.zst.age-123456.partial"),
+	require.NoError(t, os.MkdirAll(filepath.Dir(leftover), 0o750))
-		filepath.Join(storeDir, "blobs", hash[:2], hash[2:4],
+	require.NoError(t, os.WriteFile(leftover, []byte("half a blob"), 0o600))
-			hash+"-123456.partial"),
-	}
-
-	for _, leftover := range leftovers {
-		require.NoError(t, os.MkdirAll(filepath.Dir(leftover), 0o750))
-		require.NoError(t, os.WriteFile(leftover, []byte("half an upload"), 0o600))
-	}
 
 	require.NoError(t, v.NukeRemote(true))
 
 	var files []string
 
-	err = filepath.WalkDir(storeDir,
+	err := filepath.WalkDir(storeDir,
 		func(path string, entry fs.DirEntry, err error) error {
 			if err != nil {
 				return err

internal/vaultik/prune.go

@@ -49,8 +49,8 @@ func (v *Vaultik) NukeRemote(force bool) error {
 		return fmt.Errorf("pruning blobs: %w", err)
 	}
 
-	// The file and rclone listings skip `.partial` objects, so the two
+	// Listings skip `.partial` objects, so the two steps above never
-	// steps above never delete them.
+	// delete them.
 	for _, prefix := range []string{"metadata/", "blobs/"} {
 		err = v.Storage.DeletePartialUploads(v.ctx, prefix)
 		if err != nil {

internal/vaultik/snapshot.go

@@ -185,7 +185,6 @@ type snapshotStats struct {
 	totalBlobs         int
 	totalBytesSkipped  int64
 	totalFilesSkipped  int
-	totalFilesFailed   int
 	totalFilesDeleted  int
 	totalBytesDeleted  int64
 	totalBytesUploaded int64
@@ -316,7 +315,6 @@ func (v *Vaultik) scanAllDirectories(
 		stats.totalChunks += result.ChunksCreated
 		stats.totalBlobs += result.BlobsCreated
 		stats.totalFilesSkipped += result.FilesSkipped
-		stats.totalFilesFailed += result.FilesFailed
 		stats.totalBytesSkipped += result.BytesSkipped
 		stats.totalFilesDeleted += result.FilesDeleted
 		stats.totalBytesDeleted += result.BytesDeleted
@@ -328,7 +326,6 @@ func (v *Vaultik) scanAllDirectories(
 			"path", dir,
 			"files", result.FilesScanned,
 			"files_skipped", result.FilesSkipped,
-			"files_failed", result.FilesFailed,
 			"bytes", result.BytesScanned,
 			"bytes_skipped", result.BytesSkipped,
 			"chunks", result.ChunksCreated,
@@ -362,11 +359,9 @@ func (v *Vaultik) finalizeSnapshotMetadata(
 		return fmt.Errorf("getting snapshot blob sizes: %w", err)
 	}
 
-	// file_count and total_size leave out the files that could not be
-	// stored; stats.totalBytes already does.
 	extStats := snapshot.ExtendedBackupStats{
 		BackupStats: snapshot.BackupStats{
-			FilesScanned:  stats.totalFiles - stats.totalFilesFailed,
+			FilesScanned:  stats.totalFiles,
 			TotalSize:     stats.totalBytes + stats.totalBytesSkipped,
 			ChunksCreated: stats.totalChunks,
 			BlobsCreated:  stats.totalBlobs,
@@ -414,8 +409,7 @@ func (v *Vaultik) printSnapshotSummary(
 	snapshotID string, startTime time.Time, stats *snapshotStats,
 ) {
 	snapshotDuration := time.Since(startTime)
-	totalFilesChanged := stats.totalFiles - stats.totalFilesSkipped -
+	totalFilesChanged := stats.totalFiles - stats.totalFilesSkipped
-		stats.totalFilesFailed
 	totalBytesAll := stats.totalBytes + stats.totalBytesSkipped
 
 	var compressionRatio float64
@@ -432,10 +426,6 @@ func (v *Vaultik) printSnapshotSummary(
 		v.UI.Count(stats.totalFiles),
 		v.UI.Count(totalFilesChanged),
 		v.UI.Count(stats.totalFilesSkipped))
-	if stats.totalFilesFailed > 0 {
-		filesMsg += fmt.Sprintf(", %s failed", v.UI.Count(stats.totalFilesFailed))
-	}
-
 	if stats.totalFilesDeleted > 0 {
 		filesMsg += fmt.Sprintf(", %s deleted", v.UI.Count(stats.totalFilesDeleted))
 	}

internal/vaultik/snapshot_failed_file_test.go

@@ -1,123 +0,0 @@
-package vaultik_test
-
-import (
-	"bytes"
-	"context"
-	"fmt"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/spf13/afero"
-	"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/ui"
-	"sneak.berlin/go/vaultik/internal/vaultik"
-)
-
-// openFailFs is the real filesystem, except that opening path fails
-// with err. Phase 1 of a backup only lstats a file, so it still counts
-// path; phase 2 is the first to open it.
-type openFailFs struct {
-	afero.OsFs
-
-	path string
-	err  error
-}
-
-//nolint:ireturn // afero.Fs.Open is defined to return the interface.
-func (f *openFailFs) Open(name string) (afero.File, error) {
-	if name == f.path {
-		return nil, &os.PathError{Op: "open", Path: name, Err: f.err}
-	}
-
-	return f.OsFs.Open(name)
-}
-
-// A file that phase 2 cannot open is reported as failed, not as
-// unchanged, and neither the summary's data total nor the snapshots row
-// counts it. See https://git.eeqj.de/sneak/vaultik/issues/280.
-func TestSnapshotSummaryCountsFileNotStoredAsFailed(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	tests := []struct {
-		name       string
-		openErr    error
-		skipErrors bool
-	}{
-		// What a normal user gets opening a file with mode 000.
-		{name: "unopenable under skip-errors",
-			openErr: os.ErrPermission, skipErrors: true},
-		// What opening a file removed after phase 1 gives.
-		{name: "removed between the phases",
-			openErr: os.ErrNotExist, skipErrors: false},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			ctx := context.Background()
-
-			// The scan walks the source path with symlinks resolved, so
-			// failedPath must be spelled the same way to match.
-			tempDir, err := filepath.EvalSymlinks(t.TempDir())
-			require.NoError(t, err)
-
-			srcDir := filepath.Join(tempDir, "src")
-			failedPath := filepath.Join(srcDir, "failed.txt")
-			storedContent := []byte("this file is backed up")
-			storedSize := int64(len(storedContent))
-
-			fs := &openFailFs{path: failedPath, err: tt.openErr}
-			require.NoError(t, fs.MkdirAll(srcDir, 0o755))
-			require.NoError(t, afero.WriteFile(fs,
-				filepath.Join(srcDir, "stored.txt"), storedContent, 0o644))
-			require.NoError(t, afero.WriteFile(fs,
-				failedPath, []byte("this file cannot be opened"), 0o644))
-
-			cfg := faultTestConfig()
-			cfg.IndexPath = filepath.Join(tempDir, "index.sqlite")
-			cfg.Snapshots = map[string]config.SnapshotConfig{
-				"src": {Paths: []string{srcDir}},
-			}
-
-			store, err := storage.NewFileStorer(filepath.Join(tempDir, "remote"))
-			require.NoError(t, err)
-
-			db, err := database.New(ctx, cfg.IndexPath)
-			require.NoError(t, err)
-			t.Cleanup(func() { _ = db.Close() })
-
-			repos := database.NewRepositories(db)
-			out := &bytes.Buffer{}
-			v := newBackupVaultik(ctx, cfg, store, repos, db, fs)
-			v.UI = ui.NewWithColor(out, false)
-
-			require.NoError(t, v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
-				SkipErrors: tt.skipErrors,
-				Snapshots:  []string{"src"},
-			}))
-
-			summary := out.String()
-			assert.Contains(t, summary,
-				"Files: 2 examined, 1 backed up, 0 unchanged, 1 failed.")
-			assert.Contains(t, summary,
-				fmt.Sprintf("Data: %s total (%s backed up).",
-					v.UI.Size(storedSize), v.UI.Size(storedSize)))
-
-			snap, err := repos.Snapshots.GetByID(ctx,
-				localSnapshotID(ctx, t, repos, "src"))
-			require.NoError(t, err)
-			require.NotNil(t, snap)
-
-			assert.Equal(t, int64(1), snap.FileCount)
-			assert.Equal(t, storedSize, snap.TotalSize)
-		})
-	}
-}

internal/vaultik/snapshot_skip_errors_test.go

@@ -1,75 +0,0 @@
-package vaultik_test
-
-import (
-	"context"
-	"fmt"
-	"path/filepath"
-	"testing"
-
-	"github.com/spf13/afero"
-	"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/vaultik"
-)
-
-// --skip-errors skips only a file that cannot be opened or read. A local
-// index error while a directory is recorded stops the backup, and the
-// snapshot is not recorded as complete. See
-// https://git.eeqj.de/sneak/vaultik/issues/284.
-func TestSkipErrorsBackupStopsOnIndexErrorRecordingDirectory(t *testing.T) {
-	log.Initialize(log.Config{})
-	t.Parallel()
-
-	ctx := context.Background()
-
-	// The scan walks the source path with symlinks resolved, so dirPath
-	// must be spelled the same way to match the row the scan inserts.
-	tempDir, err := filepath.EvalSymlinks(t.TempDir())
-	require.NoError(t, err)
-
-	srcDir := filepath.Join(tempDir, "src")
-	dirPath := filepath.Join(srcDir, "dir")
-
-	fs := afero.NewOsFs()
-	require.NoError(t, fs.MkdirAll(dirPath, 0o755))
-	require.NoError(t, afero.WriteFile(fs,
-		filepath.Join(dirPath, "file.txt"), []byte("file content"), 0o644))
-
-	cfg := faultTestConfig()
-	cfg.IndexPath = filepath.Join(tempDir, "index.sqlite")
-	cfg.Snapshots = map[string]config.SnapshotConfig{
-		"tree": {Paths: []string{srcDir}},
-	}
-
-	store, err := storage.NewFileStorer(filepath.Join(tempDir, "remote"))
-	require.NoError(t, err)
-
-	db, err := database.New(ctx, cfg.IndexPath)
-	require.NoError(t, err)
-	t.Cleanup(func() { _ = db.Close() })
-
-	// The local index refuses the directory's files row.
-	_, err = db.Conn().ExecContext(ctx, fmt.Sprintf(`
-		CREATE TRIGGER refuse_directory BEFORE INSERT ON files
-		WHEN NEW.path = '%s'
-		BEGIN SELECT RAISE(ABORT, 'simulated index error'); END`, dirPath))
-	require.NoError(t, err)
-
-	repos := database.NewRepositories(db)
-	v := newBackupVaultik(ctx, cfg, store, repos, db, fs)
-
-	err = v.CreateSnapshot(&vaultik.SnapshotCreateOptions{
-		SkipErrors: true,
-		Snapshots:  []string{"tree"},
-	})
-	require.ErrorContains(t, err, "simulated index error")
-
-	snapshots, err := repos.Snapshots.ListRecent(ctx, listRecentTestLimit)
-	require.NoError(t, err)
-	require.Len(t, snapshots, 1)
-	assert.Nil(t, snapshots[0].CompletedAt)
-}