From ab24eb1078759840f644402a744f04b246a77ec4 Mon Sep 17 00:00:00 2001 From: Josh Gross Date: Thu, 12 Nov 2026 17:37:01 -0500 Subject: [PATCH 1/6] Only access system credential storage when needed --- internal/cmd/auth/check.go | 3 ++ internal/cmd/auth/logout.go | 3 ++ internal/cmd/root.go | 10 +---- internal/cmd/root_test.go | 48 +++++++++++++++++++++ internal/cmdutil/cmdutil.go | 3 ++ internal/config/config.go | 37 ++++++++++------ internal/config/config_test.go | 79 ++++++++++++++++++++++++++++++++++ 7 files changed, 163 insertions(+), 20 deletions(-) create mode 100644 internal/config/config_test.go diff --git a/internal/cmd/auth/check.go b/internal/cmd/auth/check.go index 323138c6..2268d035 100644 --- a/internal/cmd/auth/check.go +++ b/internal/cmd/auth/check.go @@ -13,6 +13,9 @@ func CheckCmd(ch *cmdutil.Helper) *cobra.Command { Args: cobra.NoArgs, Short: "Check if you are authenticated", RunE: func(cmd *cobra.Command, args []string) error { + if err := ch.Config.LoadAccessToken(); err != nil { + return err + } ctx := cmd.Context() resp := buildAuthCheckResponse(ctx, ch) diff --git a/internal/cmd/auth/logout.go b/internal/cmd/auth/logout.go index e333b0f8..3ddf6093 100644 --- a/internal/cmd/auth/logout.go +++ b/internal/cmd/auth/logout.go @@ -23,6 +23,9 @@ func LogoutCmd(ch *cmdutil.Helper) *cobra.Command { Args: cobra.NoArgs, Short: "Log out of the PlanetScale API", RunE: func(cmd *cobra.Command, args []string) error { + if err := ch.Config.LoadAccessToken(); err != nil { + return err + } if ch.Config.AccessToken == "" { ch.Printer.Println("Already logged out. Exiting...") return nil diff --git a/internal/cmd/root.go b/internal/cmd/root.go index eb428a71..c58a35ce 100644 --- a/internal/cmd/root.go +++ b/internal/cmd/root.go @@ -188,15 +188,12 @@ func runCmd(ctx context.Context, ver, commit, buildDate string, format *printer. rootCmd.Flags().BoolVar(&skillFlag, "skill", false, "Print the agent skill file and exit") - cfg, err := config.New() - if err != nil { - return err - } + cfg := config.New() rootCmd.PersistentFlags().StringVar(&cfg.BaseURL, "api-url", ps.DefaultBaseURL, "The base URL for the PlanetScale API.") rootCmd.PersistentFlags().StringVar(&cfg.AccessToken, - "api-token", cfg.AccessToken, "The API token to use for authenticating against the PlanetScale API.") + "api-token", "", "The API token to use for authenticating against the PlanetScale API.") rootCmd.PersistentFlags().VarP(printer.NewFormatValue(printer.Human, format), "format", "f", "Show output in a specific format. Possible values: [human, json, csv]") @@ -242,9 +239,6 @@ func runCmd(ctx context.Context, ver, commit, buildDate string, format *printer. rootCmd.PersistentFlags().MarkDeprecated("service-token-name", "use --service-token-id instead") rootCmd.PersistentFlags().MarkHidden("service-token-name") - // We don't want to show the default value - rootCmd.PersistentFlags().Lookup("api-token").DefValue = "" - // Add command groups for better organization // Every command's help/usage output ends with a pointer to the embedded // agent guide, so agents that discover pscale via --help (rather than a diff --git a/internal/cmd/root_test.go b/internal/cmd/root_test.go index 8865423d..4687aeb4 100644 --- a/internal/cmd/root_test.go +++ b/internal/cmd/root_test.go @@ -3,6 +3,7 @@ package cmd import ( "bytes" "context" + "encoding/json" "errors" "os" "os/exec" @@ -10,6 +11,7 @@ import ( "strings" "testing" + "github.com/99designs/keyring" "github.com/planetscale/cli/internal/cmd/agentguide" "github.com/planetscale/cli/internal/cmdutil" "github.com/spf13/cobra" @@ -28,6 +30,52 @@ func TestAddCommandGroupsOmitsNeki(t *testing.T) { const rootCLIHelperEnv = "PSCALE_ROOT_CLI_HELPER" +func TestStoredTokenLoadingIsLazyAndReportsJSONErrors(t *testing.T) { + for _, backend := range keyring.AvailableBackends() { + switch backend { + case keyring.KeychainBackend, keyring.SecretServiceBackend, keyring.KWalletBackend, keyring.WinCredBackend: + t.Skip("requires file fallback; run with CGO_ENABLED=0 on macOS") + } + } + home := writeHomeConfig(t, "") + // Reading a directory as a token reliably fails without touching a keychain. + if err := os.Mkdir(filepath.Join(home, ".config", "planetscale", "access-token"), 0o700); err != nil { + t.Fatal(err) + } + for _, args := range [][]string{ + {"--help", "--format", "json"}, + {"--version", "--format", "json"}, + {"--skill", "--format", "json"}, + } { + result := runRootCLIWithHome(t, home, args...) + if result.exitCode != 0 { + t.Fatalf("%v loaded stored credentials: stdout=%q stderr=%q", args, result.stdout, result.stderr) + } + } + for _, args := range [][]string{ + {"org", "list", "--format", "json"}, + {"auth", "check", "--format", "json"}, + {"auth", "logout", "--format", "json"}, + } { + result := runRootCLIWithHome(t, home, args...) + if result.exitCode != cmdutil.FatalErrExitCode { + t.Fatalf("%v exit code = %d, stdout=%q stderr=%q", args, result.exitCode, result.stdout, result.stderr) + } + var resp struct { + Status string `json:"status"` + Error string `json:"error"` + Issues []any `json:"issues"` + NextSteps []string `json:"next_steps"` + } + if err := json.Unmarshal([]byte(result.stdout), &resp); err != nil { + t.Fatalf("%v did not return one JSON envelope: %v, stdout=%q", args, err, result.stdout) + } + if resp.Status != "error" || !strings.Contains(resp.Error, "access-token") || len(resp.Issues) == 0 || len(resp.NextSteps) == 0 { + t.Fatalf("%v invalid JSON error envelope: %s", args, result.stdout) + } + } +} + func TestRootSkillFlag(t *testing.T) { for _, args := range [][]string{ {"--skill", "--format", "json"}, diff --git a/internal/cmdutil/cmdutil.go b/internal/cmdutil/cmdutil.go index 94734b9b..71fc569d 100644 --- a/internal/cmdutil/cmdutil.go +++ b/internal/cmdutil/cmdutil.go @@ -166,6 +166,9 @@ func WarnDeprecated(name, message string, next func(cmd *cobra.Command, args []s // actionable error message. func CheckAuthentication(cfg *config.Config) func(cmd *cobra.Command, args []string) error { return func(cmd *cobra.Command, args []string) error { + if err := cfg.LoadAccessToken(); err != nil { + return err + } if err := cfg.IsAuthenticated(); err != nil { if commandFormat(cmd) == printer.JSON.String() { resp := struct { diff --git a/internal/config/config.go b/internal/config/config.go index 60303875..9b0c79ef 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -7,6 +7,7 @@ import ( "os" "path/filepath" "strings" + "sync" "github.com/99designs/keyring" ps "github.com/planetscale/cli/internal/planetscale" @@ -34,21 +35,30 @@ type Config struct { ServiceTokenID string ServiceToken string + loadAccessToken func() (string, error) + // Project Configuration Database string Branch string } -func New() (*Config, error) { - accessToken, err := readAccessToken() - if err != nil { - return nil, err +func New() *Config { + return &Config{ + BaseURL: ps.DefaultBaseURL, + loadAccessToken: sync.OnceValues(readAccessToken), } +} - return &Config{ - AccessToken: accessToken, - BaseURL: ps.DefaultBaseURL, - }, nil +func (c *Config) LoadAccessToken() error { + if c.AccessToken != "" || c.ServiceTokenID != "" || c.ServiceToken != "" || c.loadAccessToken == nil { + return nil + } + token, err := c.loadAccessToken() + if err != nil { + return err + } + c.AccessToken = token + return nil } func (c *Config) IsAuthenticated() error { @@ -63,6 +73,9 @@ func (c *Config) IsAuthenticated() error { if c.ServiceTokenIsSet() { return nil } + if err := c.LoadAccessToken(); err != nil { + return err + } if c.AccessToken == "" { return errors.New("you must run 'pscale auth login' to authenticate before using this command") @@ -92,6 +105,9 @@ func (c *Config) NewClientFromConfig(clientOpts ...ps.ClientOption) (*ps.Client, if c.ServiceTokenIsSet() { opts = append(opts, ps.WithServiceToken(c.ServiceTokenID, c.ServiceToken)) } else { + if err := c.LoadAccessToken(); err != nil { + return nil, err + } opts = append(opts, ps.WithAccessToken(c.AccessToken)) } opts = append(opts, clientOpts...) @@ -264,9 +280,6 @@ func readAccessTokenPath() ([]byte, error) { stat, err := os.Stat(tokenPath) if err != nil { - if !os.IsNotExist(err) { - log.Fatal(err) - } return nil, err } else { if stat.Mode()&^tokenFileMode != 0 { @@ -277,7 +290,7 @@ func readAccessTokenPath() ([]byte, error) { } accessToken, err = os.ReadFile(tokenPath) if err != nil { - log.Fatal(err) + return nil, err } } diff --git a/internal/config/config_test.go b/internal/config/config_test.go new file mode 100644 index 00000000..e453e00b --- /dev/null +++ b/internal/config/config_test.go @@ -0,0 +1,79 @@ +package config + +import ( + "errors" + "sync" + "testing" +) + +func TestAccessTokenLookupCached(t *testing.T) { + lookupErr := errors.New("keychain access denied") + for _, tt := range []struct { + name string + token string + err error + }{ + {name: "token", token: "stored-token"}, + {name: "empty"}, + {name: "failure", err: lookupErr}, + } { + t.Run(tt.name, func(t *testing.T) { + calls := 0 + cfg := New() + cfg.loadAccessToken = sync.OnceValues(func() (string, error) { + calls++ + return tt.token, tt.err + }) + if calls != 0 { + t.Fatal("constructor loaded credentials") + } + for range 2 { + if err := cfg.LoadAccessToken(); !errors.Is(err, tt.err) { + t.Fatalf("LoadAccessToken error = %v, want %v", err, tt.err) + } + if _, err := cfg.NewClientFromConfig(); tt.err != nil && !errors.Is(err, tt.err) { + t.Fatalf("NewClientFromConfig error = %v, want %v", err, tt.err) + } + if err := cfg.IsAuthenticated(); tt.err != nil && !errors.Is(err, tt.err) { + t.Fatalf("IsAuthenticated error = %v, want %v", err, tt.err) + } + } + if calls != 1 { + t.Fatalf("credential lookups = %d, want 1", calls) + } + if cfg.AccessToken != tt.token { + t.Fatalf("access token = %q, want %q", cfg.AccessToken, tt.token) + } + }) + } +} + +func TestExplicitCredentialsSkipAccessTokenLookup(t *testing.T) { + for _, tt := range []struct { + name, token, serviceID, serviceToken string + invalid bool + }{ + {name: "api token", token: "explicit-token"}, + {name: "service token", serviceID: "id", serviceToken: "secret"}, + {name: "missing service secret", serviceID: "id", invalid: true}, + {name: "missing service id", serviceToken: "secret", invalid: true}, + } { + t.Run(tt.name, func(t *testing.T) { + cfg := New() + cfg.AccessToken, cfg.ServiceTokenID, cfg.ServiceToken = tt.token, tt.serviceID, tt.serviceToken + cfg.loadAccessToken = func() (string, error) { + t.Fatal("explicit credentials opened the keychain") + return "", nil + } + if err := cfg.LoadAccessToken(); err != nil { + t.Fatal(err) + } + if err := cfg.IsAuthenticated(); (err != nil) != tt.invalid { + t.Fatalf("IsAuthenticated error = %v, invalid = %v", err, tt.invalid) + } + if _, err := cfg.NewClientFromConfig(); (err != nil) != tt.invalid { + t.Fatalf("NewClientFromConfig error = %v, invalid = %v", err, tt.invalid) + } + }) + } +} From b304c57fec7a12ce311530b0712e9f3f0c27abee Mon Sep 17 00:00:00 2001 From: Josh Gross Date: Fri, 13 Nov 2026 12:31:24 -0500 Subject: [PATCH 2/6] Log out of stored credentials when a service token is set --- internal/cmd/auth/logout.go | 2 +- internal/config/config.go | 13 ++++++++++++- internal/config/config_test.go | 18 ++++++++++++++++++ 3 files changed, 31 insertions(+), 2 deletions(-) diff --git a/internal/cmd/auth/logout.go b/internal/cmd/auth/logout.go index 3ddf6093..7ce559f8 100644 --- a/internal/cmd/auth/logout.go +++ b/internal/cmd/auth/logout.go @@ -23,7 +23,7 @@ func LogoutCmd(ch *cmdutil.Helper) *cobra.Command { Args: cobra.NoArgs, Short: "Log out of the PlanetScale API", RunE: func(cmd *cobra.Command, args []string) error { - if err := ch.Config.LoadAccessToken(); err != nil { + if err := ch.Config.LoadStoredAccessToken(); err != nil { return err } if ch.Config.AccessToken == "" { diff --git a/internal/config/config.go b/internal/config/config.go index 9b0c79ef..08a4e547 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -49,8 +49,19 @@ func New() *Config { } } +// LoadAccessToken fills AccessToken from credential storage unless explicit +// credentials were provided. func (c *Config) LoadAccessToken() error { - if c.AccessToken != "" || c.ServiceTokenID != "" || c.ServiceToken != "" || c.loadAccessToken == nil { + if c.ServiceTokenID != "" || c.ServiceToken != "" { + return nil + } + return c.LoadStoredAccessToken() +} + +// LoadStoredAccessToken fills AccessToken from credential storage unless an +// access token was provided, even when service token credentials are set. +func (c *Config) LoadStoredAccessToken() error { + if c.AccessToken != "" || c.loadAccessToken == nil { return nil } token, err := c.loadAccessToken() diff --git a/internal/config/config_test.go b/internal/config/config_test.go index e453e00b..29e9c7bb 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -77,3 +77,21 @@ func TestExplicitCredentialsSkipAccessTokenLookup(t *testing.T) { }) } } + +func TestStoredAccessTokenLoadsWithServiceToken(t *testing.T) { + cfg := New() + cfg.ServiceTokenID, cfg.ServiceToken = "id", "secret" + cfg.loadAccessToken = func() (string, error) { return "stored-token", nil } + if err := cfg.LoadAccessToken(); err != nil { + t.Fatal(err) + } + if cfg.AccessToken != "" { + t.Fatalf("LoadAccessToken loaded %q despite service token", cfg.AccessToken) + } + if err := cfg.LoadStoredAccessToken(); err != nil { + t.Fatal(err) + } + if cfg.AccessToken != "stored-token" { + t.Fatalf("access token = %q, want stored-token", cfg.AccessToken) + } +} From ee291f9c2e7e20b994b6f69ef15c997b187f86bc Mon Sep 17 00:00:00 2001 From: Josh Gross Date: Fri, 13 Nov 2026 12:31:34 -0500 Subject: [PATCH 3/6] Report unreadable token files during keyring migration --- internal/config/config.go | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/internal/config/config.go b/internal/config/config.go index 08a4e547..2d16421d 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -202,7 +202,10 @@ func readAccessToken() (string, error) { if errors.Is(err, keyring.ErrKeyNotFound) { // Migrate to keychain accessToken, tokenErr := readAccessTokenPath() - if len(accessToken) > 0 && tokenErr == nil { + if tokenErr != nil && !os.IsNotExist(tokenErr) { + return "", tokenErr + } + if len(accessToken) > 0 { return migrateAccessToken(ring, accessToken) } // Might need to improve this, but today the empty From e79c1b9614b652ef2d8ba3008f52bf93ecf988ff Mon Sep 17 00:00:00 2001 From: Josh Gross Date: Fri, 13 Nov 2026 12:31:55 -0500 Subject: [PATCH 4/6] Delete unreadable stored tokens on logout --- internal/cmd/auth/logout.go | 22 ++++++++++++++-------- internal/cmd/root_test.go | 8 +++++++- 2 files changed, 21 insertions(+), 9 deletions(-) diff --git a/internal/cmd/auth/logout.go b/internal/cmd/auth/logout.go index 7ce559f8..653248c5 100644 --- a/internal/cmd/auth/logout.go +++ b/internal/cmd/auth/logout.go @@ -2,6 +2,8 @@ package auth import ( "bufio" + "errors" + "fmt" "io" "github.com/planetscale/cli/internal/auth" @@ -23,10 +25,9 @@ func LogoutCmd(ch *cmdutil.Helper) *cobra.Command { Args: cobra.NoArgs, Short: "Log out of the PlanetScale API", RunE: func(cmd *cobra.Command, args []string) error { - if err := ch.Config.LoadStoredAccessToken(); err != nil { - return err - } - if ch.Config.AccessToken == "" { + // An unreadable token can't be revoked, but deleting it still logs out. + readErr := ch.Config.LoadStoredAccessToken() + if readErr == nil && ch.Config.AccessToken == "" { ch.Printer.Println("Already logged out. Exiting...") return nil } @@ -45,15 +46,20 @@ func LogoutCmd(ch *cmdutil.Helper) *cobra.Command { end := ch.Printer.PrintProgress("Logging out...") defer end() - err = authenticator.RevokeToken(ctx, ch.Config.AccessToken) - if err != nil { - return err + if readErr == nil { + err = authenticator.RevokeToken(ctx, ch.Config.AccessToken) + if err != nil { + return err + } } err = config.DeleteAccessToken() if err != nil { - return err + return errors.Join(readErr, err) } end() + if readErr != nil { + fmt.Fprintf(cmd.ErrOrStderr(), "Warning: deleted the stored access token without revoking it: %v\n", readErr) + } ch.Printer.Println("Successfully logged out.") return nil diff --git a/internal/cmd/root_test.go b/internal/cmd/root_test.go index 4687aeb4..9a7e3b3f 100644 --- a/internal/cmd/root_test.go +++ b/internal/cmd/root_test.go @@ -55,7 +55,6 @@ func TestStoredTokenLoadingIsLazyAndReportsJSONErrors(t *testing.T) { for _, args := range [][]string{ {"org", "list", "--format", "json"}, {"auth", "check", "--format", "json"}, - {"auth", "logout", "--format", "json"}, } { result := runRootCLIWithHome(t, home, args...) if result.exitCode != cmdutil.FatalErrExitCode { @@ -74,6 +73,13 @@ func TestStoredTokenLoadingIsLazyAndReportsJSONErrors(t *testing.T) { t.Fatalf("%v invalid JSON error envelope: %s", args, result.stdout) } } + result := runRootCLIWithHome(t, home, "auth", "logout", "--format", "json") + if result.exitCode != 0 { + t.Fatalf("auth logout exit code = %d, stdout=%q stderr=%q", result.exitCode, result.stdout, result.stderr) + } + if _, err := os.Stat(filepath.Join(home, ".config", "planetscale", "access-token")); !os.IsNotExist(err) { + t.Fatalf("auth logout left unreadable token in place: %v", err) + } } func TestRootSkillFlag(t *testing.T) { From 9d21f927a434a5e05cfd12e95749060132b8bcf8 Mon Sep 17 00:00:00 2001 From: Josh Gross Date: Fri, 13 Nov 2026 12:32:12 -0500 Subject: [PATCH 5/6] Load stored tokens before direct token reads --- internal/cmd/api/api.go | 3 +++ internal/cmd/branch/connections/client.go | 3 +++ 2 files changed, 6 insertions(+) diff --git a/internal/cmd/api/api.go b/internal/cmd/api/api.go index 64285bd8..a2aca728 100644 --- a/internal/cmd/api/api.go +++ b/internal/cmd/api/api.go @@ -158,6 +158,9 @@ func ApiCmd(ch *cmdutil.Helper, userAgent string, defaultHeaders map[string]stri originalHost := req.URL.Hostname() redirectCheck := makeRedirectCheck(originalHost) + if err := ch.Config.LoadAccessToken(); err != nil { + return err + } var cl *http.Client if ch.Config.AccessToken != "" { // Create a transport chain that uses OAuth2 token but honors our redirect policy diff --git a/internal/cmd/branch/connections/client.go b/internal/cmd/branch/connections/client.go index b15c8727..35fdf983 100644 --- a/internal/cmd/branch/connections/client.go +++ b/internal/cmd/branch/connections/client.go @@ -146,6 +146,9 @@ func branchIsProduction(ctx context.Context, ch *cmdutil.Helper, database, branc } func newConnectionsClient(ch *cmdutil.Helper, database, branch string, target ConnectionTarget) (*live.Client, error) { + if err := ch.Config.LoadAccessToken(); err != nil { + return nil, err + } return live.NewClient(live.ClientConfig{ BaseURL: ch.Config.BaseURL, Organization: ch.Config.Organization, From 146d8b1b64784f74037edfb8b8a8917b609f6ebd Mon Sep 17 00:00:00 2001 From: Josh Gross Date: Fri, 13 Nov 2026 12:46:39 -0500 Subject: [PATCH 6/6] Remove legacy token files on keyring logout --- internal/config/config.go | 28 +++++++++++++++++++++------- internal/config/config_test.go | 33 +++++++++++++++++++++++++++++++++ 2 files changed, 54 insertions(+), 7 deletions(-) diff --git a/internal/config/config.go b/internal/config/config.go index 2d16421d..0e0ae483 100644 --- a/internal/config/config.go +++ b/internal/config/config.go @@ -259,10 +259,19 @@ func DeleteAccessToken() error { return deleteAccessTokenPath() } - return ring.Remove(keyringKey) + // Remove the token file left by keyring migration so a later read + // doesn't migrate it back or fail on it. + if err := deleteAccessTokenFile(); err != nil { + return err + } + err = ring.Remove(keyringKey) + if err != nil && !errors.Is(err, keyring.ErrKeyNotFound) { + return err + } + return nil } -func openKeyring() (keyring.Keyring, error) { +var openKeyring = func() (keyring.Keyring, error) { return keyring.Open(keyring.Config{ AllowedBackends: []keyring.BackendType{ keyring.SecretServiceBackend, @@ -311,17 +320,22 @@ func readAccessTokenPath() ([]byte, error) { return accessToken, nil } -func deleteAccessTokenPath() error { +func deleteAccessTokenFile() error { tokenPath, err := accessTokenPath() if err != nil { return err } err = os.Remove(tokenPath) - if err != nil { - if !os.IsNotExist(err) { - return fmt.Errorf("error removing access token file: %w", err) - } + if err != nil && !os.IsNotExist(err) { + return fmt.Errorf("error removing access token file: %w", err) + } + return nil +} + +func deleteAccessTokenPath() error { + if err := deleteAccessTokenFile(); err != nil { + return err } configFile, err := DefaultConfigPath() diff --git a/internal/config/config_test.go b/internal/config/config_test.go index 29e9c7bb..e8eb8904 100644 --- a/internal/config/config_test.go +++ b/internal/config/config_test.go @@ -2,8 +2,13 @@ package config import ( "errors" + "os" + "path/filepath" "sync" "testing" + + "github.com/99designs/keyring" + "github.com/mitchellh/go-homedir" ) func TestAccessTokenLookupCached(t *testing.T) { @@ -95,3 +100,31 @@ func TestStoredAccessTokenLoadsWithServiceToken(t *testing.T) { t.Fatalf("access token = %q, want stored-token", cfg.AccessToken) } } + +func TestDeleteAccessTokenRemovesUnreadableTokenFile(t *testing.T) { + home := t.TempDir() + t.Setenv("HOME", home) + homedir.Reset() + t.Cleanup(homedir.Reset) + ring := keyring.NewArrayKeyring(nil) + original := openKeyring + openKeyring = func() (keyring.Keyring, error) { return ring, nil } + t.Cleanup(func() { openKeyring = original }) + + tokenPath := filepath.Join(home, ".config", "planetscale", "access-token") + if err := os.MkdirAll(tokenPath, 0o700); err != nil { + t.Fatal(err) + } + if _, err := readAccessToken(); err == nil { + t.Fatal("readAccessToken succeeded on an unreadable token file") + } + if err := DeleteAccessToken(); err != nil { + t.Fatal(err) + } + if _, err := os.Stat(tokenPath); !os.IsNotExist(err) { + t.Fatalf("token file still exists: %v", err) + } + if token, err := readAccessToken(); token != "" || err != nil { + t.Fatalf("readAccessToken = %q, %v after delete", token, err) + } +}