package storageurl_test import ( "errors" "reflect" "strings" "testing" "sneak.berlin/go/vaultik/internal/storageurl" ) // 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 ( bucket = "mybucket" fileScheme = "file" ) cases := []struct { name string raw string want *storageurl.URL }{ { name: "file absolute path", raw: "file:///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: &storageurl.URL{Scheme: fileScheme, Prefix: "/Volumes/my stick/backup"}, }, { name: "file path with a literal space", raw: "file:///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: &storageurl.URL{ Scheme: "s3", Bucket: bucket, Prefix: "backups/host", UseSSL: true, }, }, { name: "s3 bucket only", raw: "s3://mybucket", 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: &storageurl.URL{ Scheme: "s3", Bucket: bucket, Endpoint: "minio.example.com", Region: "us-west-2", UseSSL: false, }, }, { name: "rclone remote and path", raw: "rclone://gdrive/backups/host", want: &storageurl.URL{ Scheme: "rclone", RcloneRemote: "gdrive", Prefix: "backups/host", }, }, { name: "rclone remote only", raw: "rclone://gdrive", want: &storageurl.URL{Scheme: "rclone", RcloneRemote: "gdrive"}, }, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { t.Parallel() got, err := storageurl.Parse(tc.raw) if err != nil { t.Fatalf("Parse(%q) returned error: %v", tc.raw, err) } if !reflect.DeepEqual(got, tc.want) { t.Errorf("Parse(%q) = %+v, want %+v", tc.raw, got, tc.want) } }) } } // 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 { name string raw string wantErr error }{ {"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 := storageurl.Parse(tc.raw) if !errors.Is(err, tc.wantErr) { t.Errorf("Parse(%q) error = %v, want %v", tc.raw, err, tc.wantErr) } }) } } // 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 // tooling would flag as a real hardcoded credential. const ( key = "AKIAKEY" secret = "topsecret" ) cases := []struct { name string raw string wantErr error secrets []string // must not appear in the error message }{ { name: "s3 userinfo", raw: "s3://" + key + ":" + secret + "@mybucket/prefix", wantErr: storageurl.ErrURLCredentials, secrets: []string{key, secret, "mybucket"}, }, { name: "s3 userinfo in endpoint", raw: "s3://mybucket?endpoint=https://" + key + ":" + secret + "@minio.example.com", wantErr: storageurl.ErrURLCredentials, secrets: []string{key, secret}, }, { name: "s3 userinfo in endpoint without scheme", raw: "s3://mybucket?endpoint=" + key + ":" + secret + "@minio.example.com", wantErr: storageurl.ErrURLCredentials, secrets: []string{key, secret}, }, { name: "s3 unknown query param", raw: "s3://mybucket?access_key=" + key + "&secret=" + secret, wantErr: storageurl.ErrURLUnknownParam, secrets: []string{key, secret}, }, { name: "s3 misspelt endpoint", raw: "s3://mybucket?endpiont=minio.example.com", wantErr: storageurl.ErrURLUnknownParam, secrets: nil, }, { name: "rclone userinfo", raw: "rclone://user:" + secret + "@gdrive/backups", wantErr: storageurl.ErrURLCredentials, secrets: []string{secret}, }, { name: "rclone query param", raw: "rclone://gdrive/backups?token=" + secret, wantErr: storageurl.ErrURLUnknownParam, secrets: []string{secret}, }, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { t.Parallel() _, err := storageurl.Parse(tc.raw) if !errors.Is(err, tc.wantErr) { t.Fatalf("Parse(%q) error = %v, want %v", tc.raw, err, tc.wantErr) } // The rejection must name the proper config keys so the // operator knows where credentials belong. for _, key := range []string{"s3.access_key_id", "s3.secret_access_key"} { if !strings.Contains(err.Error(), key) { t.Errorf("error %q does not name %q", err.Error(), key) } } for _, secret := range tc.secrets { if strings.Contains(err.Error(), secret) { t.Errorf("error message leaked %q: %v", secret, err.Error()) } } }) } } // 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 { name string raw string secrets []string // must not appear in the error message }{ { name: "configured remote", raw: "rclone://gdrive,client_secret=topsecret/backups", secrets: []string{"topsecret"}, }, { name: "remote defined inline", raw: "rclone://:s3,access_key_id=KEY,secret_access_key=SECRET/bucket", secrets: []string{"KEY", "SECRET"}, }, { name: "colon in a parameter value", raw: "rclone://gdrive,client_secret=ab:cd/backups", secrets: []string{"cd"}, }, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { t.Parallel() _, 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 { if strings.Contains(err.Error(), secret) { t.Errorf("error message leaked %q: %v", secret, err.Error()) } } }) } } // 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 ( key = "AKIAKEY" secret = "topsecret" ) cases := []struct { name string raw string }{ { name: "semicolon", raw: "s3://mybucket/prefix?endpoint=https://" + key + ":" + secret + "@minio.example.com:9000;region=us-east-1", }, { name: "bad percent escape", raw: "s3://mybucket/prefix?endpoint=https://" + key + ":" + secret + "%zz@minio.example.com:9000", }, { name: "rclone semicolon", raw: "rclone://gdrive/backups?token=" + secret + ";x=1", }, { name: "rclone bad percent escape", raw: "rclone://gdrive/backups?token=" + secret + "%zz", }, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { t.Parallel() _, err := storageurl.Parse(tc.raw) if err == nil { t.Fatalf("Parse(%q) returned no error", tc.raw) } 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"} { if strings.Contains(err.Error(), s) { t.Errorf("error message leaked %q: %v", s, err.Error()) } } }) } } // 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 := storageurl.Parse(raw) if err == nil { t.Fatalf("Parse(%q) returned no error", raw) } if strings.Contains(err.Error(), "mybucket") { t.Errorf("error message echoed the raw URL: %v", err.Error()) } }