Read the snapshot name using the stored hostname (closes #230)

A snapshot ID is hostname_name_timestamp, and purge took the name to be
everything between the first and the last underscore. With a hostname
such as my_host the name home came out as host_home, so
`snapshot purge --keep-latest --snapshot home` found nothing to delete
and `snapshot create --prune` purged nothing without a message. The name
is now read by removing the hostname stored with the snapshot, in the
short form the ID uses, so both may contain underscores. This was chosen
over rejecting underscores in `hostname` when the config loads, which
would also stop restores on such a host.

The purge consistency test stored a hostname that did not match its
snapshot IDs; it now matches, as it always does in production.

Model: opus-5-5

TODO.md

@@ -22,27 +22,6 @@ the tag exists and is exercised; what is left is merging `next` to
 
 # Completed Steps
 
-- 2026-10-07: Made two messages say only what is true
-  ([issue #240](https://git.eeqj.de/sneak/vaultik/issues/240)). A config
-  file that others can read was warned about as containing S3
-  credentials even when it set none, as a `file://` config does. The
-  warning now says the file may contain S3 credentials only when
-  `s3.access_key_id` or `s3.secret_access_key` is set, since either may
-  come from a `${...}` reference rather than the file, and otherwise
-  says the file is readable by others. `snapshot purge` against a
-  destination store it could not list gave an error with
-  `listing remote snapshots:` in it twice; the prefix now appears once.
-
-- 2026-10-07: Made `s3.part_size` set the multipart upload part size
-  ([issue #232](https://git.eeqj.de/sneak/vaultik/issues/232)). It was
-  loaded and defaulted but never passed to the S3 client, whose uploader
-  used a fixed 10MiB part. It now reaches the uploader for `storage_url`
-  and for the `s3.*` fields, and a part size S3 refuses, below 5MiB or
-  above 5GiB, `0` included, fails at config load. A blob too large for
-  S3's limit of 10,000 parts at the configured size is uploaded in larger
-  parts. The docs gave the default as `5MB`, which the config file reads
-  as 5,000,000 bytes, below the minimum; they now say `5MiB`.
-
 - 2026-10-07: Made per-name retention work when the hostname contains `_`
   ([issue #230](https://git.eeqj.de/sneak/vaultik/issues/230)). A
   snapshot ID is `hostname_name_timestamp`, and the name was read as

config.example.yml

@@ -287,11 +287,10 @@ storage_url: "rclone://myremote/path/to/backups"
 #  #use_ssl: true
 #
 #  # Part size for multipart uploads
-#  # Minimum 5MiB, maximum 5GiB; affects memory usage during upload
-#  # A blob too large for 10,000 parts of this size gets larger parts
-#  # Supports: 10MB, 16MiB, 100MiB, etc. (5MB is below the minimum)
-#  # Default: 5MiB
-#  #part_size: 5MiB
+#  # Minimum 5MB, affects memory usage during upload
+#  # Supports: 5MB, 10M, 100MiB, etc.
+#  # Default: 5MB
+#  #part_size: 5MB
 
 # Path to local SQLite index database
 # This database tracks file state for incremental backups

internal/cli/config.go

@@ -205,7 +205,7 @@ storage_url: ""
 #   access_key_id: YOUR_ACCESS_KEY
 #   secret_access_key: YOUR_SECRET_KEY
 #   # region: us-east-1        # Default: us-east-1
-#   # part_size: 5MiB          # Upload part size, 5MiB to 5GiB. Default: 5MiB
+#   # part_size: 5MB           # Multipart upload part size. Default: 5MB
 #   # For the s3:// form, disable TLS with ?ssl=false in the URL, not use_ssl.
 
 # ─── OPTIONAL ────────────────────────────────────────────────────────────────

internal/config/config.go

@@ -33,14 +33,11 @@ const secretKeyPrefix = "AGE-SECRET-KEY-"
 const (
 	defaultBlobSizeLimit    = Size(10 * 1024 * 1024 * 1024) // 10GB
 	defaultChunkSize        = Size(10 * 1024 * 1024)        // 10MB
-	defaultS3PartSize       = Size(5 * 1024 * 1024)         // 5MiB
+	defaultS3PartSize       = Size(5 * 1024 * 1024)         // 5MB
 	defaultCompressionLevel = 3
 	minChunkSize            = 1024 * 1024 // 1MB
 	minCompressionLevel     = 1
 	maxCompressionLevel     = 19
-	// S3 accepts a multipart upload part from 5MiB to 5GiB.
-	minS3PartSize = 5 * 1024 * 1024
-	maxS3PartSize = 5 * 1024 * 1024 * 1024
 )
 
 // Sentinel validation errors.
@@ -58,7 +55,6 @@ var (
 		"blob_size_limit must be at least the largest chunk the chunker can " +
 			"emit (chunk_size times the FastCDC size spread)")
 	errBadCompression   = errors.New("compression_level must be between 1 and 19")
-	errBadS3PartSize    = errors.New("s3.part_size must be between 5MiB and 5GiB")
 	errBadStorageScheme = errors.New(
 		"storage_url must start with s3://, file://, or rclone://")
 	errStorageNotConfigured = errors.New(
@@ -248,7 +244,6 @@ func Load(path string) (*Config, error) {
 		ChunkSize:        defaultChunkSize,
 		IndexPath:        filepath.Join(xdg.DataHome, appName, "index.sqlite"),
 		CompressionLevel: defaultCompressionLevel,
-		S3:               S3Config{PartSize: defaultS3PartSize},
 	}
 
 	// Convert smartconfig data to YAML then unmarshal
@@ -299,13 +294,17 @@ func Load(path string) (*Config, error) {
 		cfg.S3.Region = "us-east-1"
 	}
 
+	if cfg.S3.PartSize == 0 {
+		cfg.S3.PartSize = defaultS3PartSize
+	}
+
 	// Check config file permissions (warn if world or group readable)
 	//nolint:gosec // G703: config path is operator-supplied by design
 	info, statErr := os.Stat(path)
 	if statErr == nil {
 		mode := info.Mode().Perm()
 		if mode&0044 != 0 { // group or world readable
-			log.Warn(cfg.readableByOthersWarning(),
+			log.Warn("Config file has insecure permissions (contains S3 credentials)",
 				"path", path,
 				"mode", fmt.Sprintf("%04o", mode),
 				"recommendation", "chmod 600 "+path)
@@ -333,7 +332,6 @@ func Load(path string) (*Config, error) {
 //     (chunk_size times chunker.ChunkSizeSpread), so a single-chunk blob never
 //     exceeds the configured limit
 //   - Compression level must be between 1 and 19
-//   - S3 part size must be between 5MiB and 5GiB, the part sizes S3 accepts
 //
 // Returns an error describing the first validation failure encountered.
 func (c *Config) Validate() error {
@@ -378,11 +376,6 @@ func (c *Config) Validate() error {
 		return errBadCompression
 	}
 
-	if c.S3.PartSize.Int64() < minS3PartSize ||
-		c.S3.PartSize.Int64() > maxS3PartSize {
-		return errBadS3PartSize
-	}
-
 	return nil
 }
 
@@ -418,18 +411,6 @@ func (c *Config) setAgeSecretKey() {
 	}
 }
 
-// readableByOthersWarning is the warning Load logs when others can read
-// the config file. It says "may contain" because the S3 credentials are
-// seen only after smartconfig has replaced any ${...} reference in the
-// file with its value, so a set credential need not be in the file.
-func (c *Config) readableByOthersWarning() string {
-	if c.S3.AccessKeyID != "" || c.S3.SecretAccessKey != "" {
-		return "Config file is readable by others and may contain S3 credentials"
-	}
-
-	return "Config file is readable by others"
-}
-
 // validateStorage validates storage configuration.
 // If StorageURL is set, it takes precedence. S3 URLs require credentials.
 // File URLs don't require any S3 configuration.

internal/config/config_test.go

@@ -8,7 +8,6 @@ import (
 	"testing"
 
 	"sneak.berlin/go/vaultik/internal/chunker"
-	"sneak.berlin/go/vaultik/internal/log"
 )
 
 const (
@@ -167,7 +166,6 @@ func TestValidateBlobSizeLimit(t *testing.T) {
 			ChunkSize:        chunkSize,
 			BlobSizeLimit:    blobLimit,
 			CompressionLevel: 3,
-			S3:               S3Config{PartSize: defaultS3PartSize},
 		}
 	}
 
@@ -223,120 +221,6 @@ func TestValidateBlobSizeLimit(t *testing.T) {
 	}
 }
 
-// TestValidateS3PartSize checks that s3.part_size is held to the part sizes
-// S3 accepts, 5MiB to 5GiB, by changing only the part size of the test
-// config. "5MB" in the config file is 5,000,000 bytes, below the minimum.
-func TestValidateS3PartSize(t *testing.T) {
-	t.Parallel()
-
-	base, err := Load(os.Getenv("VAULTIK_CONFIG"))
-	if err != nil {
-		t.Fatalf("Failed to load config: %v", err)
-	}
-
-	tests := []struct {
-		name     string
-		partSize Size
-		wantErr  bool
-	}{
-		{
-			name:     "5MB is rejected",
-			partSize: 5_000_000,
-			wantErr:  true,
-		},
-		{
-			name:     "one byte below 5MiB is rejected",
-			partSize: minS3PartSize - 1,
-			wantErr:  true,
-		},
-		{
-			name:     "5MiB is accepted",
-			partSize: minS3PartSize,
-			wantErr:  false,
-		},
-		{
-			name:     "5GiB is accepted",
-			partSize: maxS3PartSize,
-			wantErr:  false,
-		},
-		{
-			name:     "one byte above 5GiB is rejected",
-			partSize: maxS3PartSize + 1,
-			wantErr:  true,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			cfg := *base
-			cfg.S3.PartSize = tt.partSize
-
-			err := cfg.Validate()
-			if tt.wantErr {
-				if !errors.Is(err, errBadS3PartSize) {
-					t.Fatalf("Validate() error = %v, want errBadS3PartSize", err)
-				}
-
-				return
-			}
-
-			if err != nil {
-				t.Fatalf("Validate() unexpected error: %v", err)
-			}
-		})
-	}
-}
-
-// TestLoadS3PartSize checks that a config file without s3.part_size loads
-// with the 5MiB default, and that an explicit 0 fails at load like any other
-// part size S3 refuses.
-func TestLoadS3PartSize(t *testing.T) {
-	t.Parallel()
-
-	const withoutPartSize = "snapshots:\n" +
-		"  test:\n" +
-		"    paths: [/tmp/vaultik-test-source]\n" +
-		"storage_url: file:///tmp/vaultik-test-storage\n"
-
-	writeConfig := func(t *testing.T, text string) string {
-		t.Helper()
-
-		path := filepath.Join(t.TempDir(), "config.yml")
-
-		err := os.WriteFile(path, []byte(text), 0o600)
-		if err != nil {
-			t.Fatalf("write config: %v", err)
-		}
-
-		return path
-	}
-
-	t.Run("absent loads as 5MiB", func(t *testing.T) {
-		t.Parallel()
-
-		cfg, err := Load(writeConfig(t, withoutPartSize))
-		if err != nil {
-			t.Fatalf("Load() unexpected error: %v", err)
-		}
-
-		if cfg.S3.PartSize != defaultS3PartSize {
-			t.Errorf("s3.part_size = %d, want %d",
-				cfg.S3.PartSize, defaultS3PartSize)
-		}
-	})
-
-	t.Run("0 is rejected", func(t *testing.T) {
-		t.Parallel()
-
-		_, err := Load(writeConfig(t, withoutPartSize+"s3:\n  part_size: 0\n"))
-		if !errors.Is(err, errBadS3PartSize) {
-			t.Fatalf("Load() error = %v, want errBadS3PartSize", err)
-		}
-	})
-}
-
 // TestValidateAgeRecipients checks that recipients are parsed at config load
 // (a bad entry fails immediately, not mid-backup) and that no invalid entry —
 // least of all a pasted secret key — is echoed in the error. An empty list
@@ -352,7 +236,6 @@ func TestValidateAgeRecipients(t *testing.T) {
 			ChunkSize:        Size(10 * 1024 * 1024),
 			BlobSizeLimit:    Size(10 * 1024 * 1024 * 1024),
 			CompressionLevel: 3,
-			S3:               S3Config{PartSize: defaultS3PartSize},
 		}
 	}
 
@@ -460,125 +343,3 @@ func TestAgeSecretKeySourceName(t *testing.T) {
 		})
 	}
 }
-
-// loadReadableConfig writes configYAML to a file that others can read,
-// loads it, and returns what the logger wrote to stderr meanwhile. The
-// logger writes to the os.Stderr it finds when it is initialized, so
-// os.Stderr is pointed at a file first. Not parallel-safe: os.Stderr and
-// the logger are process-global.
-func loadReadableConfig(t *testing.T, configYAML string) string {
-	t.Helper()
-
-	dir := t.TempDir()
-	configPath := filepath.Join(dir, "config.yml")
-	stderrPath := filepath.Join(dir, "stderr")
-
-	err := os.WriteFile(configPath, []byte(configYAML), 0o600)
-	if err != nil {
-		t.Fatalf("writing config: %v", err)
-	}
-
-	//nolint:gosec // G302: the test needs a config file others can read
-	err = os.Chmod(configPath, 0o644)
-	if err != nil {
-		t.Fatalf("chmod config: %v", err)
-	}
-
-	stderrFile, err := os.Create(stderrPath) //nolint:gosec // G304: test temp path
-	if err != nil {
-		t.Fatalf("creating stderr file: %v", err)
-	}
-
-	previous := os.Stderr
-	os.Stderr = stderrFile
-
-	log.Initialize(log.Config{})
-
-	_, loadErr := Load(configPath)
-
-	os.Stderr = previous
-
-	log.Initialize(log.Config{})
-
-	_ = stderrFile.Close()
-
-	if loadErr != nil {
-		t.Fatalf("Load() error = %v", loadErr)
-	}
-
-	captured, err := os.ReadFile(stderrPath) //nolint:gosec // G304: test temp path
-	if err != nil {
-		t.Fatalf("reading stderr file: %v", err)
-	}
-
-	return string(captured)
-}
-
-// TestLoadWarnsReadableConfigWithoutS3Credentials checks that a config
-// file others can read, holding no S3 credentials, is warned about
-// without a claim that it holds them.
-//
-//nolint:paralleltest // loadReadableConfig replaces os.Stderr
-func TestLoadWarnsReadableConfigWithoutS3Credentials(t *testing.T) {
-	stderr := loadReadableConfig(t, `
-storage_url: file:///var/backups/vaultik
-snapshots:
-  home:
-    paths:
-      - /home
-`)
-
-	if !strings.Contains(stderr, "Config file is readable by others") {
-		t.Errorf("expected a warning that the file is readable by others, got %q",
-			stderr)
-	}
-
-	if strings.Contains(stderr, "S3 credentials") {
-		t.Errorf("warning names S3 credentials the file does not set: %q", stderr)
-	}
-}
-
-// TestLoadWarnsReadableConfigWithS3Credentials checks that a config file
-// others can read and that sets S3 credentials, as values or as ${ENV:...}
-// references, is warned about as one that may contain them.
-//
-//nolint:paralleltest // loadReadableConfig replaces os.Stderr
-func TestLoadWarnsReadableConfigWithS3Credentials(t *testing.T) {
-	t.Setenv("VAULTIK_TEST_ACCESS_KEY_ID", "test-access-key")
-	t.Setenv("VAULTIK_TEST_SECRET_ACCESS_KEY", "test-secret-key")
-
-	configs := map[string]string{
-		"values": `
-storage_url: s3://bucket/prefix?endpoint=s3.example.com
-s3:
-  access_key_id: test-access-key
-  secret_access_key: test-secret-key
-snapshots:
-  home:
-    paths:
-      - /home
-`,
-		"references": `
-storage_url: s3://bucket/prefix?endpoint=s3.example.com
-s3:
-  access_key_id: ${ENV:VAULTIK_TEST_ACCESS_KEY_ID}
-  secret_access_key: ${ENV:VAULTIK_TEST_SECRET_ACCESS_KEY}
-snapshots:
-  home:
-    paths:
-      - /home
-`,
-	}
-
-	for name, configYAML := range configs {
-		t.Run(name, func(t *testing.T) {
-			stderr := loadReadableConfig(t, configYAML)
-
-			if !strings.Contains(stderr,
-				"Config file is readable by others and may contain S3 credentials") {
-				t.Errorf("expected a warning naming the S3 credentials, got %q",
-					stderr)
-			}
-		})
-	}
-}

internal/s3/client.go

@@ -27,12 +27,10 @@ type Client struct {
 	bucket   string
 	prefix   string
 	endpoint string
-	partSize int64
 }
 
 // Config contains S3 client configuration.
-// All fields are required except Prefix, which defaults to an empty string,
-// and PartSize, where zero means the SDK default of 5 MiB.
+// All fields are required except Prefix, which defaults to an empty string.
 // A non-empty Prefix is joined to every key with one "/", whether or not
 // it ends with one.
 // The Endpoint field should include the protocol (http:// or https://).
@@ -43,9 +41,6 @@ type Config struct {
 	AccessKeyID     string
 	SecretAccessKey string
 	Region          string
-	// PartSize is the size in bytes of each part of a multipart upload.
-	// An upload too large for S3's limit of 10,000 parts gets larger parts.
-	PartSize int64
 }
 
 // nopLogger is a logger that discards all output.
@@ -95,7 +90,6 @@ func NewClient(ctx context.Context, cfg Config) (*Client, error) {
 		bucket:   cfg.Bucket,
 		prefix:   prefix,
 		endpoint: cfg.Endpoint,
-		partSize: cfg.PartSize,
 	}, nil
 }
 
@@ -129,9 +123,12 @@ func (c *Client) PutObjectWithProgress(
 ) error {
 	fullKey := c.prefix + key
 
+	// uploadPartSize is 10MB for better progress granularity.
+	const uploadPartSize = 10 * 1024 * 1024
+
 	// Create an uploader with the S3 client
 	uploader := manager.NewUploader(c.s3Client, func(u *manager.Uploader) {
-		u.PartSize = uploadPartSize(c.partSize, size)
+		u.PartSize = uploadPartSize
 	})
 
 	// Create a progress reader that tracks upload progress
@@ -152,21 +149,6 @@ func (c *Client) PutObjectWithProgress(
 	return err
 }
 
-// uploadPartSize returns the part size for an upload of size bytes: the
-// configured part size (the SDK default when zero), raised where needed so
-// the upload fits in S3's limit of 10,000 parts. The uploader cannot raise
-// it itself, because it cannot seek the progress reader to learn its size.
-func uploadPartSize(configured, size int64) int64 {
-	if configured == 0 {
-		configured = manager.DefaultUploadPartSize
-	}
-
-	maxParts := int64(manager.MaxUploadParts)
-	smallestThatFits := (size + maxParts - 1) / maxParts // rounded up
-
-	return max(configured, smallestThatFits)
-}
-
 // GetObject downloads an object from S3 with the specified key.
 // The key is automatically prefixed with the configured prefix.
 // Returns a ReadCloser containing the object data. The caller must

internal/s3/client_internal_test.go

@@ -1,55 +0,0 @@
-package s3
-
-import "testing"
-
-// TestUploadPartSize checks that an upload too large for 10,000 parts of the
-// configured size gets parts just large enough to fit in 10,000.
-func TestUploadPartSize(t *testing.T) {
-	t.Parallel()
-
-	const mib = 1024 * 1024
-
-	tests := []struct {
-		name       string
-		configured int64
-		size       int64
-		want       int64
-	}{
-		{
-			name:       "an upload that fits keeps the configured size",
-			configured: 5 * mib,
-			size:       10 * 1024 * mib,
-			want:       5 * mib,
-		},
-		{
-			name:       "exactly 10,000 parts keeps the configured size",
-			configured: 6 * mib,
-			size:       10_000 * 6 * mib,
-			want:       6 * mib,
-		},
-		{
-			name:       "one byte more than 10,000 parts adds a byte to each",
-			configured: 6 * mib,
-			size:       10_000*6*mib + 1,
-			want:       6*mib + 1,
-		},
-		{
-			name:       "zero means the SDK default of 5MiB",
-			configured: 0,
-			size:       1,
-			want:       5 * mib,
-		},
-	}
-
-	for _, tt := range tests {
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-
-			got := uploadPartSize(tt.configured, tt.size)
-			if got != tt.want {
-				t.Errorf("uploadPartSize(%d, %d) = %d, want %d",
-					tt.configured, tt.size, got, tt.want)
-			}
-		})
-	}
-}

internal/s3/module.go

@@ -28,7 +28,6 @@ func provideClient(lc fx.Lifecycle, cfg *config.Config) (*Client, error) {
 		AccessKeyID:     cfg.S3.AccessKeyID,
 		SecretAccessKey: cfg.S3.SecretAccessKey,
 		Region:          cfg.S3.Region,
-		PartSize:        cfg.S3.PartSize.Int64(),
 	})
 	if err != nil {
 		return nil, err

internal/storage/module.go

@@ -99,7 +99,6 @@ func storerFromParsedS3URL(parsed *URL, cfg *config.Config) (Storer, error) {
 		AccessKeyID:     cfg.S3.AccessKeyID,
 		SecretAccessKey: cfg.S3.SecretAccessKey,
 		Region:          region,
-		PartSize:        cfg.S3.PartSize.Int64(),
 	})
 	if err != nil {
 		return nil, fmt.Errorf("creating S3 client: %w", err)
@@ -135,7 +134,6 @@ func storerFromLegacyS3Config(cfg *config.Config) (Storer, error) {
 		AccessKeyID:     cfg.S3.AccessKeyID,
 		SecretAccessKey: cfg.S3.SecretAccessKey,
 		Region:          region,
-		PartSize:        cfg.S3.PartSize.Int64(),
 	})
 	if err != nil {
 		return nil, fmt.Errorf("creating S3 client: %w", err)

internal/storage/s3_test.go

@@ -1,14 +1,11 @@
 package storage_test
 
 import (
-	"bytes"
 	"context"
 	"errors"
-	"net/http"
 	"net/http/httptest"
 	"slices"
 	"strings"
-	"sync/atomic"
 	"testing"
 
 	"github.com/johannesboyne/gofakes3"
@@ -22,13 +19,6 @@ import (
 // s3TestBucket is the bucket created for each in-process S3 server.
 const s3TestBucket = "test-bucket"
 
-// Credentials for the tests that build a storer from a config.Config. The
-// in-process S3 server accepts any.
-const (
-	s3TestAccessKeyID     = "key"
-	s3TestSecretAccessKey = "secret"
-)
-
 // newS3Storer builds an s3:// backend backed by a fresh in-process
 // S3 server. It reuses the same in-memory S3 harness (gofakes3 + s3mem
 // over httptest) that internal/s3 and the not-found regression test use,
@@ -138,8 +128,8 @@ func TestS3URLPrefixKeyLayout(t *testing.T) {
 			storer, err := storage.NewStorer(&config.Config{
 				StorageURL: storageURL + "?endpoint=" + srv.URL,
 				S3: config.S3Config{
-					AccessKeyID:     s3TestAccessKeyID,
-					SecretAccessKey: s3TestSecretAccessKey,
+					AccessKeyID:     "key",
+					SecretAccessKey: "secret",
 				},
 			})
 			if err != nil {
@@ -181,90 +171,6 @@ func TestS3URLPrefixKeyLayout(t *testing.T) {
 	}
 }
 
-// TestS3UploadUsesConfiguredPartSize checks that s3.part_size reaches the
-// multipart uploader, through storage_url and through the s3.* fields. An
-// object three parts long must arrive as three parts; at the SDK's default
-// of 5 MiB it would arrive as four.
-func TestS3UploadUsesConfiguredPartSize(t *testing.T) {
-	t.Parallel()
-
-	const (
-		partSize  = 6 * 1024 * 1024
-		wantParts = 3
-	)
-
-	backend := s3mem.New()
-
-	err := backend.CreateBucket(s3TestBucket)
-	if err != nil {
-		t.Fatalf("create bucket: %v", err)
-	}
-
-	// Every part of a multipart upload is one request with a partNumber.
-	var parts atomic.Int32
-
-	fake := gofakes3.New(backend).Server()
-	srv := httptest.NewServer(http.HandlerFunc(
-		func(w http.ResponseWriter, r *http.Request) {
-			if r.URL.Query().Has("partNumber") {
-				parts.Add(1)
-			}
-
-			fake.ServeHTTP(w, r)
-		}))
-	t.Cleanup(srv.Close)
-
-	cases := []struct {
-		name string
-		cfg  *config.Config
-	}{
-		{
-			name: "storage_url",
-			cfg: &config.Config{
-				StorageURL: "s3://" + s3TestBucket + "?endpoint=" + srv.URL,
-				S3: config.S3Config{
-					AccessKeyID:     s3TestAccessKeyID,
-					SecretAccessKey: s3TestSecretAccessKey,
-					PartSize:        partSize,
-				},
-			},
-		},
-		{
-			name: "s3.endpoint",
-			cfg: &config.Config{
-				S3: config.S3Config{
-					Endpoint:        srv.URL,
-					Bucket:          s3TestBucket,
-					AccessKeyID:     s3TestAccessKeyID,
-					SecretAccessKey: s3TestSecretAccessKey,
-					PartSize:        partSize,
-				},
-			},
-		},
-	}
-
-	for _, tc := range cases {
-		parts.Store(0)
-
-		storer, err := storage.NewStorer(tc.cfg)
-		if err != nil {
-			t.Fatalf("%s: NewStorer: %v", tc.name, err)
-		}
-
-		data := bytes.NewReader(make([]byte, wantParts*partSize))
-
-		err = storer.PutWithProgress(
-			context.Background(), "blob", data, data.Size(), nil)
-		if err != nil {
-			t.Fatalf("%s: PutWithProgress: %v", tc.name, err)
-		}
-
-		if got := parts.Load(); got != wantParts {
-			t.Errorf("%s: uploaded in %d parts, want %d", tc.name, got, wantParts)
-		}
-	}
-}
-
 // listStreamKeys returns the keys ListStream yields under a prefix, and
 // fails the test on a listing error.
 func listStreamKeys(t *testing.T, s storage.Storer, prefix string) []string {

internal/vaultik/missing_destination_test.go

@@ -6,7 +6,6 @@ import (
 	"io/fs"
 	"os"
 	"path/filepath"
-	"strings"
 	"testing"
 
 	"github.com/spf13/afero"
@@ -154,23 +153,3 @@ func TestPruneKeepsLocalRecordsWhenDestinationMissing(t *testing.T) {
 	require.NoError(t, err)
 	assert.Len(t, snapshots, 1, "prune must delete no local snapshot record")
 }
-
-// TestPurgeSaysListingFailedOnceWhenDestinationMissing checks that
-// snapshot purge fails on a destination it cannot list, with an error
-// that says "listing remote snapshots" once.
-//
-//nolint:paralleltest // installs the global logger via log.Initialize
-func TestPurgeSaysListingFailedOnceWhenDestinationMissing(t *testing.T) {
-	log.Initialize(log.Config{})
-
-	ctx := context.Background()
-	v, _, _ := backUpThenUnplug(ctx, t)
-
-	err := v.PurgeSnapshotsWithOptions(&vaultik.SnapshotPurgeOptions{
-		KeepLatest: true,
-		Force:      true,
-	})
-	require.ErrorIs(t, err, fs.ErrNotExist)
-	assert.Equal(t, 1, strings.Count(err.Error(), "listing remote snapshots"),
-		err.Error())
-}

internal/vaultik/snapshot.go

@@ -1052,7 +1052,7 @@ func (v *Vaultik) syncWithRemote() error {
 	// every local snapshot record (issue #160).
 	remoteKeys, err := v.listAllRemoteSnapshotKeys()
 	if err != nil {
-		return err
+		return fmt.Errorf("listing remote snapshots: %w", err)
 	}
 
 	remoteKeySet := make(map[string]bool, len(remoteKeys))

test/config.yaml

@@ -19,7 +19,7 @@ s3:
   secret_access_key: test-secret-key
   region: us-east-1
   use_ssl: true
-  part_size: 5242880  # 5MiB
+  part_size: 5242880  # 5MB
 index_path: /tmp/vaultik-test.sqlite
 chunk_size: 10MB
 blob_size_limit: 10GB