From 57b5cb327bec483e8a374b3b610da523f6d94cbc Mon Sep 17 00:00:00 2001 From: clawbot <35+clawbot@noreply.example.org> Date: Thu, 19 Nov 2026 14:33:22 +0100 Subject: [PATCH] Check storage_url with the storage parser at config load (closes #468) config set accepted rclone:// values that every command then refused: no remote name, parameters in the remote name, a query parameter. The config only checked the URL's prefix, because config could not import the parser from storage, which imports config. The parser moves from internal/storage to a new package, internal/storageurl, that both import. ParseStorageURL becomes storageurl.Parse. Loading the config now runs it on every storage_url, so config set refuses such a value and leaves the file unchanged. Model: opus-5-5 --- internal/cli/config_test.go | 7 + internal/config/config.go | 61 +++----- internal/config/config_test.go | 5 +- internal/storage/file.go | 3 +- internal/storage/module.go | 16 +- internal/storage/rclone.go | 3 +- internal/{storage => storageurl}/url.go | 30 ++-- .../url_test.go} | 137 +++++++++--------- 8 files changed, 133 insertions(+), 129 deletions(-) rename internal/{storage => storageurl}/url.go (92%) rename internal/{storage/url_parse_test.go => storageurl/url_test.go} (59%) diff --git a/internal/cli/config_test.go b/internal/cli/config_test.go index 1eb657f..adc1584 100644 --- a/internal/cli/config_test.go +++ b/internal/cli/config_test.go @@ -282,6 +282,13 @@ func TestConfigSetKeepsFileThatWouldNotLoad(t *testing.T) { storageURLKey, testS3URL, "s3.secret_access_key is required for s3:// URLs; " + "set s3.access_key_id and s3.secret_access_key first"}, + // rclone:// URLs that no command could open. + {configWithoutRecipients, storageURLKey, "rclone:///backups", + "rclone URL missing remote name"}, + {configWithoutRecipients, storageURLKey, "rclone://dav,user=x/backups", + "rclone URL must not carry parameters in the remote name"}, + {configWithoutRecipients, storageURLKey, "rclone://dav/backups?x=1", + `unknown query parameter in storage URL: "x"`}, // With its reference filled in, the config loads. {levelReference, "blob_size_limit", "1MB", "blob_size_limit must be at least"}, diff --git a/internal/config/config.go b/internal/config/config.go index 1e2e1c3..41a784c 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -21,6 +21,7 @@ import ( "gopkg.in/yaml.v3" "sneak.berlin/go/vaultik/internal/chunker" "sneak.berlin/go/vaultik/internal/log" + "sneak.berlin/go/vaultik/internal/storageurl" ) const appName = "vaultik" @@ -63,13 +64,8 @@ var ( errBlobSizeTooSmall = errors.New( "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://") - errFileURLNotAbsolute = errors.New( - "a file:// storage_url needs an absolute path, " + - "as in file:///path/to/backup") + errBadCompression = errors.New("compression_level must be between 1 and 19") + errBadS3PartSize = errors.New("s3.part_size must be between 5MiB and 5GiB") errIndexPathNotAbsolute = errors.New( "index_path and VAULTIK_INDEX_PATH need an absolute path, " + "as in ~/.local/share/vaultik/index.sqlite") @@ -558,38 +554,29 @@ func (c *Config) validateStorage() error { return nil } -// validateStorageURL validates URL-based storage configuration. File and -// rclone URLs need no credentials; S3 URLs require the legacy s3.* -// credential fields. A file URL must name an absolute path: a relative one -// would resolve against the working directory, so the destination would -// move with it. +// validateStorageURL checks storage_url with the same parser that opens +// the destination, so a value every command would refuse fails at load. +// File and rclone URLs need no credentials; S3 URLs require the legacy +// s3.* credential fields. func (c *Config) validateStorageURL() error { - switch { - case strings.HasPrefix(c.StorageURL, "file://"): - // storage.ParseStorageURL applies the same rule, but config - // cannot import storage, which imports config. - if !strings.HasPrefix(c.StorageURL, "file:///") { - return errFileURLNotAbsolute - } - - return nil - case strings.HasPrefix(c.StorageURL, "rclone://"): - // Rclone storage uses rclone's own config - return nil - case strings.HasPrefix(c.StorageURL, "s3://"): - // S3 storage needs credentials - if c.S3.AccessKeyID == "" { - return fmt.Errorf("%w for s3:// URLs", ErrS3KeyIDRequired) - } - - if c.S3.SecretAccessKey == "" { - return fmt.Errorf("%w for s3:// URLs", ErrS3SecretRequired) - } - - return nil - default: - return errBadStorageScheme + parsed, err := storageurl.Parse(c.StorageURL) + if err != nil { + return fmt.Errorf("invalid storage_url: %w", err) } + + if parsed.Scheme != storageurl.SchemeS3 { + return nil + } + + if c.S3.AccessKeyID == "" { + return fmt.Errorf("%w for s3:// URLs", ErrS3KeyIDRequired) + } + + if c.S3.SecretAccessKey == "" { + return fmt.Errorf("%w for s3:// URLs", ErrS3SecretRequired) + } + + return nil } // Module exports the config module for fx dependency injection. diff --git a/internal/config/config_test.go b/internal/config/config_test.go index 186ea5a..cfd6403 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -10,6 +10,7 @@ import ( "sneak.berlin/go/vaultik/internal/chunker" "sneak.berlin/go/vaultik/internal/log" + "sneak.berlin/go/vaultik/internal/storageurl" ) const ( @@ -502,8 +503,8 @@ func TestLoadRejectsRelativeFileURL(t *testing.T) { } _, err = Load(path) - if !errors.Is(err, errFileURLNotAbsolute) { - t.Fatalf("Load() error = %v, want errFileURLNotAbsolute", err) + if !errors.Is(err, storageurl.ErrRelativeFilePath) { + t.Fatalf("Load() error = %v, want storageurl.ErrRelativeFilePath", err) } if !strings.Contains(err.Error(), "absolute path") { diff --git a/internal/storage/file.go b/internal/storage/file.go index 8f50931..9238696 100644 --- a/internal/storage/file.go +++ b/internal/storage/file.go @@ -9,6 +9,7 @@ import ( "strings" "github.com/spf13/afero" + "sneak.berlin/go/vaultik/internal/storageurl" ) // FileStorer implements Storer using the local filesystem. @@ -301,7 +302,7 @@ func (f *FileStorer) ListPartialUploads( // Info returns human-readable storage location information. func (f *FileStorer) Info() Info { return Info{ - Type: schemeFile, + Type: storageurl.SchemeFile, Location: f.basePath, } } diff --git a/internal/storage/module.go b/internal/storage/module.go index 8d00ea1..e6ffece 100644 --- a/internal/storage/module.go +++ b/internal/storage/module.go @@ -2,14 +2,20 @@ package storage import ( "context" + "errors" "fmt" "strings" "go.uber.org/fx" "sneak.berlin/go/vaultik/internal/config" "sneak.berlin/go/vaultik/internal/s3" + "sneak.berlin/go/vaultik/internal/storageurl" ) +// ErrUnsupportedStorage is returned for a parsed storage URL whose scheme +// has no storage backend. +var ErrUnsupportedStorage = errors.New("unsupported storage scheme") + // defaultS3Region is used when neither the URL nor the config specify one. const defaultS3Region = "us-east-1" @@ -40,19 +46,19 @@ func NewStorer(cfg *config.Config) (Storer, error) { //nolint:ireturn // factory intentionally returns the Storer interface func storerFromURL(rawURL string, cfg *config.Config) (Storer, error) { - parsed, err := ParseStorageURL(rawURL) + parsed, err := storageurl.Parse(rawURL) if err != nil { return nil, fmt.Errorf("parsing storage URL: %w", err) } switch parsed.Scheme { - case schemeFile: + case storageurl.SchemeFile: return NewFileStorer(parsed.Prefix) - case schemeS3: + case storageurl.SchemeS3: return storerFromParsedS3URL(parsed, cfg) - case schemeRclone: + case storageurl.SchemeRclone: return NewRcloneStorer( context.Background(), parsed.RcloneRemote, parsed.Prefix) @@ -65,7 +71,7 @@ func storerFromURL(rawURL string, cfg *config.Config) (Storer, error) { // filling endpoint protocol and region defaults from the config. // //nolint:ireturn // factory intentionally returns the Storer interface -func storerFromParsedS3URL(parsed *URL, cfg *config.Config) (Storer, error) { +func storerFromParsedS3URL(parsed *storageurl.URL, cfg *config.Config) (Storer, error) { // Build endpoint URL endpoint := parsed.Endpoint if endpoint == "" { diff --git a/internal/storage/rclone.go b/internal/storage/rclone.go index 01b8842..370bfbb 100644 --- a/internal/storage/rclone.go +++ b/internal/storage/rclone.go @@ -16,6 +16,7 @@ import ( "github.com/rclone/rclone/fs/config" "github.com/rclone/rclone/fs/config/configfile" "github.com/rclone/rclone/fs/operations" + "sneak.berlin/go/vaultik/internal/storageurl" // Import all rclone backends _ "github.com/rclone/rclone/backend/all" @@ -288,7 +289,7 @@ func (r *RcloneStorer) Info() Info { } return Info{ - Type: schemeRclone, + Type: storageurl.SchemeRclone, Location: location, } } diff --git a/internal/storage/url.go b/internal/storageurl/url.go similarity index 92% rename from internal/storage/url.go rename to internal/storageurl/url.go index 8d2b046..e8bf97f 100644 --- a/internal/storage/url.go +++ b/internal/storageurl/url.go @@ -1,4 +1,7 @@ -package storage +// Package storageurl parses the storage_url config value. The config +// package uses it to refuse a bad value when the config loads; the storage +// package uses it to open the destination. +package storageurl import ( "errors" @@ -10,9 +13,9 @@ import ( // Storage URL scheme names. const ( - schemeFile = "file" - schemeS3 = "s3" - schemeRclone = "rclone" + SchemeFile = "file" + SchemeS3 = "s3" + SchemeRclone = "rclone" ) // Sentinel errors for storage URL parsing. @@ -25,8 +28,7 @@ var ( ErrMissingRemote = errors.New("rclone URL missing remote name") ErrUnsupportedScheme = errors.New( "unsupported URL scheme: must start with s3://, file://, or rclone://") - ErrUnsupportedStorage = errors.New("unsupported storage scheme") - ErrURLCredentials = errors.New( + ErrURLCredentials = errors.New( "storage URL must not carry credentials; " + "set s3.access_key_id and s3.secret_access_key in the config instead") ErrURLUnknownParam = errors.New("unknown query parameter in storage URL") @@ -49,12 +51,12 @@ type URL struct { RcloneRemote string // rclone remote name (for rclone:// URLs) } -// ParseStorageURL parses a storage URL string. +// Parse parses a storage URL string. // Supported formats: // - s3://bucket/prefix?endpoint=host®ion=us-east-1&ssl=true // - file:///absolute/path/to/backup // - rclone://remote/path/to/backups -func ParseStorageURL(rawURL string) (*URL, error) { +func Parse(rawURL string) (*URL, error) { if rawURL == "" { return nil, ErrEmptyStorageURL } @@ -92,7 +94,7 @@ func parseFileURL(rawPath string) (*URL, error) { return nil, fmt.Errorf("invalid file URL path: %w", err) } - return &URL{Scheme: schemeFile, Prefix: path}, nil + return &URL{Scheme: SchemeFile, Prefix: path}, nil } // parseS3URL parses an s3://bucket/prefix URL. It rejects credentials in @@ -135,7 +137,7 @@ func parseS3URL(rawURL string) (*URL, error) { } return &URL{ - Scheme: schemeS3, + Scheme: SchemeS3, Bucket: bucket, Prefix: strings.TrimPrefix(u.Path, "/"), Endpoint: query.Get("endpoint"), @@ -189,7 +191,7 @@ func parseRcloneURL(rawURL string) (*URL, error) { } return &URL{ - Scheme: schemeRclone, + Scheme: SchemeRclone, Prefix: strings.TrimPrefix(u.Path, "/"), RcloneRemote: remote, }, nil @@ -226,9 +228,9 @@ func wrapParseError(err error) error { // String returns a human-readable representation of the storage URL. func (u *URL) String() string { switch u.Scheme { - case schemeFile: + case SchemeFile: return "file://" + u.Prefix - case schemeS3: + case SchemeS3: endpoint := u.Endpoint if endpoint == "" { endpoint = "s3.amazonaws.com" @@ -239,7 +241,7 @@ func (u *URL) String() string { } return fmt.Sprintf("s3://%s (endpoint: %s)", u.Bucket, endpoint) - case schemeRclone: + case SchemeRclone: if u.Prefix != "" { return fmt.Sprintf("rclone://%s/%s", u.RcloneRemote, u.Prefix) } diff --git a/internal/storage/url_parse_test.go b/internal/storageurl/url_test.go similarity index 59% rename from internal/storage/url_parse_test.go rename to internal/storageurl/url_test.go index b6a9424..40bb06e 100644 --- a/internal/storage/url_parse_test.go +++ b/internal/storageurl/url_test.go @@ -1,4 +1,4 @@ -package storage_test +package storageurl_test import ( "errors" @@ -6,12 +6,12 @@ import ( "strings" "testing" - "sneak.berlin/go/vaultik/internal/storage" + "sneak.berlin/go/vaultik/internal/storageurl" ) -// TestParseStorageURLValid checks that each supported scheme parses into -// the expected fields, since those fields decide which backend is built. -func TestParseStorageURLValid(t *testing.T) { +// TestParseValid checks that each supported scheme parses into the +// expected fields, since those fields decide which backend is built. +func TestParseValid(t *testing.T) { t.Parallel() const ( @@ -22,27 +22,27 @@ func TestParseStorageURLValid(t *testing.T) { cases := []struct { name string raw string - want *storage.URL + want *storageurl.URL }{ { name: "file absolute path", raw: "file:///var/backups/vaultik", - want: &storage.URL{Scheme: fileScheme, Prefix: "/var/backups/vaultik"}, + want: &storageurl.URL{Scheme: fileScheme, Prefix: "/var/backups/vaultik"}, }, { name: "file percent-escaped path is decoded", raw: "file:///Volumes/my%20stick/backup", - want: &storage.URL{Scheme: fileScheme, Prefix: "/Volumes/my stick/backup"}, + want: &storageurl.URL{Scheme: fileScheme, Prefix: "/Volumes/my stick/backup"}, }, { name: "file path with a literal space", raw: "file:///Volumes/my stick/backup", - want: &storage.URL{Scheme: fileScheme, Prefix: "/Volumes/my stick/backup"}, + want: &storageurl.URL{Scheme: fileScheme, Prefix: "/Volumes/my stick/backup"}, }, { name: "s3 bucket and prefix, ssl defaults on", raw: "s3://mybucket/backups/host", - want: &storage.URL{ + want: &storageurl.URL{ Scheme: "s3", Bucket: bucket, Prefix: "backups/host", UseSSL: true, }, @@ -50,12 +50,12 @@ func TestParseStorageURLValid(t *testing.T) { { name: "s3 bucket only", raw: "s3://mybucket", - want: &storage.URL{Scheme: "s3", Bucket: bucket, UseSSL: true}, + want: &storageurl.URL{Scheme: "s3", Bucket: bucket, UseSSL: true}, }, { name: "s3 with endpoint, region, ssl off", raw: "s3://mybucket?endpoint=minio.example.com®ion=us-west-2&ssl=false", - want: &storage.URL{ + want: &storageurl.URL{ Scheme: "s3", Bucket: bucket, Endpoint: "minio.example.com", Region: "us-west-2", UseSSL: false, }, @@ -63,14 +63,14 @@ func TestParseStorageURLValid(t *testing.T) { { name: "rclone remote and path", raw: "rclone://gdrive/backups/host", - want: &storage.URL{ + want: &storageurl.URL{ Scheme: "rclone", RcloneRemote: "gdrive", Prefix: "backups/host", }, }, { name: "rclone remote only", raw: "rclone://gdrive", - want: &storage.URL{Scheme: "rclone", RcloneRemote: "gdrive"}, + want: &storageurl.URL{Scheme: "rclone", RcloneRemote: "gdrive"}, }, } @@ -78,22 +78,22 @@ func TestParseStorageURLValid(t *testing.T) { t.Run(tc.name, func(t *testing.T) { t.Parallel() - got, err := storage.ParseStorageURL(tc.raw) + got, err := storageurl.Parse(tc.raw) if err != nil { - t.Fatalf("ParseStorageURL(%q) returned error: %v", tc.raw, err) + t.Fatalf("Parse(%q) returned error: %v", tc.raw, err) } if !reflect.DeepEqual(got, tc.want) { - t.Errorf("ParseStorageURL(%q) = %+v, want %+v", tc.raw, got, tc.want) + t.Errorf("Parse(%q) = %+v, want %+v", tc.raw, got, tc.want) } }) } } -// TestParseStorageURLErrors checks that empty, missing, and unknown-scheme -// inputs fail with the documented sentinel errors instead of parsing to a -// wrong destination. -func TestParseStorageURLErrors(t *testing.T) { +// TestParseErrors checks that empty, missing, and unknown-scheme inputs +// fail with the documented sentinel errors instead of parsing to a wrong +// destination. +func TestParseErrors(t *testing.T) { t.Parallel() cases := []struct { @@ -101,34 +101,33 @@ func TestParseStorageURLErrors(t *testing.T) { raw string wantErr error }{ - {"empty url", "", storage.ErrEmptyStorageURL}, - {"file empty path", "file://", storage.ErrEmptyFilePath}, - {"file relative path", "file://dest", storage.ErrRelativeFilePath}, - {"s3 missing bucket", "s3://", storage.ErrMissingBucket}, - {"s3 missing bucket with path", "s3:///justprefix", storage.ErrMissingBucket}, - {"rclone missing remote", "rclone://", storage.ErrMissingRemote}, - {"unknown scheme", "gs://bucket/x", storage.ErrUnsupportedScheme}, - {"no scheme", "/local/path", storage.ErrUnsupportedScheme}, + {"empty url", "", storageurl.ErrEmptyStorageURL}, + {"file empty path", "file://", storageurl.ErrEmptyFilePath}, + {"file relative path", "file://dest", storageurl.ErrRelativeFilePath}, + {"s3 missing bucket", "s3://", storageurl.ErrMissingBucket}, + {"s3 missing bucket with path", "s3:///justprefix", storageurl.ErrMissingBucket}, + {"rclone missing remote", "rclone://", storageurl.ErrMissingRemote}, + {"unknown scheme", "gs://bucket/x", storageurl.ErrUnsupportedScheme}, + {"no scheme", "/local/path", storageurl.ErrUnsupportedScheme}, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { t.Parallel() - _, err := storage.ParseStorageURL(tc.raw) + _, err := storageurl.Parse(tc.raw) if !errors.Is(err, tc.wantErr) { - t.Errorf("ParseStorageURL(%q) error = %v, want %v", + t.Errorf("Parse(%q) error = %v, want %v", tc.raw, err, tc.wantErr) } }) } } -// TestParseStorageURLRejectsCredentials checks that a URL carrying -// credentials in its userinfo or in an unknown query parameter is -// rejected, and that the error never echoes the secret-bearing URL back -// into logs or output. -func TestParseStorageURLRejectsCredentials(t *testing.T) { +// TestParseRejectsCredentials checks that a URL carrying credentials in +// its userinfo or in an unknown query parameter is rejected, and that the +// error never echoes the secret-bearing URL back into logs or output. +func TestParseRejectsCredentials(t *testing.T) { t.Parallel() // Split so the literals never form a "user:pass@" URL pattern that @@ -147,44 +146,44 @@ func TestParseStorageURLRejectsCredentials(t *testing.T) { { name: "s3 userinfo", raw: "s3://" + key + ":" + secret + "@mybucket/prefix", - wantErr: storage.ErrURLCredentials, + wantErr: storageurl.ErrURLCredentials, secrets: []string{key, secret, "mybucket"}, }, { name: "s3 userinfo in endpoint", raw: "s3://mybucket?endpoint=https://" + key + ":" + secret + "@minio.example.com", - wantErr: storage.ErrURLCredentials, + wantErr: storageurl.ErrURLCredentials, secrets: []string{key, secret}, }, { name: "s3 userinfo in endpoint without scheme", raw: "s3://mybucket?endpoint=" + key + ":" + secret + "@minio.example.com", - wantErr: storage.ErrURLCredentials, + wantErr: storageurl.ErrURLCredentials, secrets: []string{key, secret}, }, { name: "s3 unknown query param", raw: "s3://mybucket?access_key=" + key + "&secret=" + secret, - wantErr: storage.ErrURLUnknownParam, + wantErr: storageurl.ErrURLUnknownParam, secrets: []string{key, secret}, }, { name: "s3 misspelt endpoint", raw: "s3://mybucket?endpiont=minio.example.com", - wantErr: storage.ErrURLUnknownParam, + wantErr: storageurl.ErrURLUnknownParam, secrets: nil, }, { name: "rclone userinfo", raw: "rclone://user:" + secret + "@gdrive/backups", - wantErr: storage.ErrURLCredentials, + wantErr: storageurl.ErrURLCredentials, secrets: []string{secret}, }, { name: "rclone query param", raw: "rclone://gdrive/backups?token=" + secret, - wantErr: storage.ErrURLUnknownParam, + wantErr: storageurl.ErrURLUnknownParam, secrets: []string{secret}, }, } @@ -193,9 +192,9 @@ func TestParseStorageURLRejectsCredentials(t *testing.T) { t.Run(tc.name, func(t *testing.T) { t.Parallel() - _, err := storage.ParseStorageURL(tc.raw) + _, err := storageurl.Parse(tc.raw) if !errors.Is(err, tc.wantErr) { - t.Fatalf("ParseStorageURL(%q) error = %v, want %v", + t.Fatalf("Parse(%q) error = %v, want %v", tc.raw, err, tc.wantErr) } @@ -216,11 +215,11 @@ func TestParseStorageURLRejectsCredentials(t *testing.T) { } } -// TestParseStorageURLRejectsRcloneRemoteParams checks that an rclone -// remote name carrying parameters (rclone's "remote,param=value" form, -// which can hold a credential) is rejected without echoing the value, -// including the URLs that url.Parse itself refuses. -func TestParseStorageURLRejectsRcloneRemoteParams(t *testing.T) { +// TestParseRejectsRcloneRemoteParams checks that an rclone remote name +// carrying parameters (rclone's "remote,param=value" form, which can hold +// a credential) is rejected without echoing the value, including the URLs +// that url.Parse itself refuses. +func TestParseRejectsRcloneRemoteParams(t *testing.T) { t.Parallel() cases := []struct { @@ -249,10 +248,10 @@ func TestParseStorageURLRejectsRcloneRemoteParams(t *testing.T) { t.Run(tc.name, func(t *testing.T) { t.Parallel() - _, err := storage.ParseStorageURL(tc.raw) - if !errors.Is(err, storage.ErrRcloneRemoteParams) { - t.Fatalf("ParseStorageURL(%q) error = %v, want %v", - tc.raw, err, storage.ErrRcloneRemoteParams) + _, err := storageurl.Parse(tc.raw) + if !errors.Is(err, storageurl.ErrRcloneRemoteParams) { + t.Fatalf("Parse(%q) error = %v, want %v", + tc.raw, err, storageurl.ErrRcloneRemoteParams) } for _, secret := range tc.secrets { @@ -264,10 +263,10 @@ func TestParseStorageURLRejectsRcloneRemoteParams(t *testing.T) { } } -// TestParseStorageURLRejectsUndecodableQuery checks that an s3 or rclone -// URL whose query cannot be decoded is rejected, not read with that part -// of the query left out, and that the error does not echo it. -func TestParseStorageURLRejectsUndecodableQuery(t *testing.T) { +// TestParseRejectsUndecodableQuery checks that an s3 or rclone URL whose +// query cannot be decoded is rejected, not read with that part of the +// query left out, and that the error does not echo it. +func TestParseRejectsUndecodableQuery(t *testing.T) { t.Parallel() const ( @@ -303,14 +302,14 @@ func TestParseStorageURLRejectsUndecodableQuery(t *testing.T) { t.Run(tc.name, func(t *testing.T) { t.Parallel() - _, err := storage.ParseStorageURL(tc.raw) + _, err := storageurl.Parse(tc.raw) if err == nil { - t.Fatalf("ParseStorageURL(%q) returned no error", tc.raw) + t.Fatalf("Parse(%q) returned no error", tc.raw) } - if !errors.Is(err, storage.ErrURLBadQuery) { - t.Errorf("ParseStorageURL(%q) error = %v, want %v", - tc.raw, err, storage.ErrURLBadQuery) + if !errors.Is(err, storageurl.ErrURLBadQuery) { + t.Errorf("Parse(%q) error = %v, want %v", + tc.raw, err, storageurl.ErrURLBadQuery) } for _, s := range []string{key, secret, "minio.example.com"} { @@ -322,17 +321,17 @@ func TestParseStorageURLRejectsUndecodableQuery(t *testing.T) { } } -// TestParseStorageURLParseFailureHidesURL checks that when url.Parse -// itself fails, the wrapped error carries only the inner cause, not the -// *url.Error whose text embeds the raw (possibly credential-bearing) URL. -func TestParseStorageURLParseFailureHidesURL(t *testing.T) { +// TestParseFailureHidesURL checks that when url.Parse itself fails, the +// wrapped error carries only the inner cause, not the *url.Error whose +// text embeds the raw (possibly credential-bearing) URL. +func TestParseFailureHidesURL(t *testing.T) { t.Parallel() const raw = "s3://mybucket/%zz" - _, err := storage.ParseStorageURL(raw) + _, err := storageurl.Parse(raw) if err == nil { - t.Fatalf("ParseStorageURL(%q) returned no error", raw) + t.Fatalf("Parse(%q) returned no error", raw) } if strings.Contains(err.Error(), "mybucket") {