Add kv suspend / resume commands (#431)

Adds the ability to suspend and resume Key Values from the command line.

https://linear.app/render-com/issue/GROW-2516/kv-resume
https://linear.app/render-com/issue/GROW-2517/kv-suspend

GitOrigin-RevId: a9097d810d98a4abc142299d461e30c9f7f79b11

Author: davidharting

cmd/kvresume.go

@@ -0,0 +1,90 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/keyvalue"
+	"github.com/render-oss/cli/pkg/resolve"
+	"github.com/render-oss/cli/pkg/text"
+	kvtypes "github.com/render-oss/cli/pkg/types/keyvalue"
+)
+
+var kvResumeCmd = &cobra.Command{
+	Use:          "resume <keyValueID|keyValueName>",
+	Short:        "Resume a suspended Key Value store instance",
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	Long: `Resume a suspended Key Value store instance on Render.
+
+The positional argument accepts either a Key Value ID (red-...) or a name.
+If the name matches more than one instance, narrow the search with
+--environment <id|name>, or pass the Key Value ID directly.
+
+Name lookup is scoped to your active workspace. If a name isn't found, switch
+workspaces with 'render workspace set <name|ID>' and try again, or pass the
+Key Value ID instead (which works across workspaces).`,
+	Example: `  # Resume by ID
+  render ea kv resume red-abc123def456ghi789jkl0
+
+  # Resume by name
+  render ea kv resume my-cache
+
+  # Disambiguate a name that exists in multiple environments
+  render ea kv resume my-cache --environment production
+
+  # JSON output
+  render ea kv resume red-abc123def456ghi789jkl0 --output json`,
+}
+
+func init() {
+	kvResumeCmd.Flags().String("environment", "",
+		"Environment ID or name (optional). Narrows name lookup when the same Key Value name exists in multiple environments.")
+
+	kvResumeCmd.RunE = func(cmd *cobra.Command, args []string) error {
+		command.DefaultFormatNonInteractive(cmd)
+
+		var input kvtypes.KeyValueResumeInput
+		if err := command.ParseCommand(cmd, args, &input); err != nil {
+			return err
+		}
+		input = kvtypes.NormalizeResumeInput(input)
+
+		loadData := func() (*client.KeyValueDetail, error) {
+			var project *client.Project
+			var env *client.Environment
+			if input.EnvironmentIDOrName != nil {
+				c, err := client.NewDefaultClient()
+				if err != nil {
+					return nil, err
+				}
+				scope, err := resolve.New(c).ResolveScopeInActiveWorkspace(cmd.Context(), resolve.ActiveWorkspaceScopeInput{
+					EnvironmentIDOrName: input.EnvironmentIDOrName,
+				})
+				if err != nil {
+					return nil, err
+				}
+				project = scope.Project
+				env = scope.Environment
+			}
+			kv, err := keyvalue.Resolve(cmd.Context(), input.IDOrName, project, env)
+			if err != nil {
+				return nil, err
+			}
+			if err := keyvalue.Resume(cmd.Context(), kv.Id); err != nil {
+				return nil, err
+			}
+			return keyvalue.Resolve(cmd.Context(), kv.Id, project, env)
+		}
+
+		_, err := command.NonInteractive(cmd, loadData, formatResumeTextOutput)
+		return err
+	}
+
+	kvCmd.AddCommand(kvResumeCmd)
+}
+
+func formatResumeTextOutput(kv *client.KeyValueDetail) string {
+	return "Resumed this Key Value:\n\n" + text.KeyValueDetail(kv) + "\n"
+}

cmd/kvresume_test.go

@@ -0,0 +1,162 @@
+package cmd
+
+import (
+	"encoding/json"
+	"net/http"
+	"testing"
+
+	renderapi "github.com/render-oss/cli/internal/fakes/renderapi"
+	"github.com/render-oss/cli/internal/testids"
+	"github.com/render-oss/cli/pkg/client"
+	"github.com/spf13/pflag"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+// executeKVResume runs `render ea kv resume <args>` against the fake server.
+// Seeds and selects an active workspace before running the command.
+func executeKVResume(t *testing.T, server *renderapi.Server, extraArgs ...string) (CommandResult, error) {
+	t.Helper()
+	t.Cleanup(resetKVResumeFlags)
+	resetKVResumeFlags()
+
+	server.Owners.Add(renderapi.NewOwner(client.Owner{Id: ACTIVE_WORKSPACE_ID, Name: "Test Workspace"}))
+	session := newCommandSession(t, server)
+	if _, err := session.execute("workspace", "set", ACTIVE_WORKSPACE_ID, "--output", "text"); err != nil {
+		return CommandResult{}, err
+	}
+	resetKVResumeFlags()
+
+	args := append([]string{"ea", "kv", "resume"}, extraArgs...)
+	return session.execute(args...)
+}
+
+func resetKVResumeFlags() {
+	rootCmd.PersistentFlags().VisitAll(func(f *pflag.Flag) {
+		if f.Name == "output" {
+			f.Changed = false
+			f.Value.Set(f.DefValue) //nolint:errcheck
+		}
+	})
+	kvResumeCmd.Flags().VisitAll(func(f *pflag.Flag) {
+		f.Changed = false
+		f.Value.Set(f.DefValue) //nolint:errcheck
+	})
+}
+
+// seedSuspendedKV adds a KV pre-seeded with Suspended status so resume tests
+// can assert the status flips back to Available.
+func seedSuspendedKV(server *renderapi.Server, name string) *client.KeyValueDetail {
+	kv := seedKV(server, name)
+	kv.Status = client.DatabaseStatusSuspended
+	return kv
+}
+
+func TestKVResume_ByID_Resumes(t *testing.T) {
+	server := renderapi.NewServer(t)
+	kv := seedSuspendedKV(server, "my-cache")
+
+	result, err := executeKVResume(t, server, kv.Id, "--output", "text")
+	require.NoError(t, err)
+
+	assert.Equal(t, client.DatabaseStatusAvailable, server.KV.Instances[0].Status)
+	assert.Contains(t, result.Stdout, "Resumed")
+	assert.Contains(t, result.Stdout, kv.Id)
+}
+
+func TestKVResume_ByName_Resumes(t *testing.T) {
+	server := renderapi.NewServer(t)
+	kv := seedSuspendedKV(server, "by-name-cache")
+
+	result, err := executeKVResume(t, server, "by-name-cache", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Equal(t, client.DatabaseStatusAvailable, server.KV.Instances[0].Status)
+	assert.Contains(t, result.Stdout, "Resumed")
+	assert.Contains(t, result.Stdout, kv.Id)
+}
+
+func TestKVResume_NameCollision_Errors(t *testing.T) {
+	server := renderapi.NewServer(t)
+	seedSuspendedKV(server, "key-value-not-unique-name")
+	seedSuspendedKV(server, "key-value-not-unique-name")
+
+	_, err := executeKVResume(t, server, "key-value-not-unique-name", "--output", "text")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "Multiple Key Value instances")
+	for _, kv := range server.KV.Instances {
+		assert.Equal(t, client.DatabaseStatusSuspended, kv.Status, "no resume on ambiguity")
+	}
+	assert.False(t, server.HasRequest("POST", "/key-value/"))
+}
+
+func TestKVResume_UnknownID_Errors(t *testing.T) {
+	server := renderapi.NewServer(t)
+	missing := testids.KeyValueID("missing")
+
+	_, err := executeKVResume(t, server, missing, "--output", "text")
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), missing)
+	assert.Contains(t, err.Error(), "No Key Value with ID")
+}
+
+func TestKVResume_JSONOutput(t *testing.T) {
+	server := renderapi.NewServer(t)
+	kv := seedSuspendedKV(server, "json-cache")
+
+	result, err := executeKVResume(t, server, kv.Id, "--output", "json")
+	require.NoError(t, err)
+	assert.Equal(t, client.DatabaseStatusAvailable, server.KV.Instances[0].Status)
+
+	var body struct {
+		ID     string `json:"id"`
+		Name   string `json:"name"`
+		Status string `json:"status"`
+	}
+	require.NoError(t, json.Unmarshal([]byte(result.Stdout), &body))
+	assert.Equal(t, kv.Id, body.ID)
+	assert.Equal(t, "json-cache", body.Name)
+	assert.Equal(t, string(client.DatabaseStatusAvailable), body.Status)
+}
+
+func TestKVResume_NameCollision_NarrowedByEnvironment_Resumes(t *testing.T) {
+	server := renderapi.NewServer(t)
+	projectID := testids.ProjectID("project")
+	envProdID := testids.EnvironmentID("production")
+	envStagingID := testids.EnvironmentID("staging")
+	server.Projects.Add(renderapi.NewProject(renderapi.ProjectAttrs{Id: projectID, Name: "My Project", OwnerId: ACTIVE_WORKSPACE_ID}))
+	server.Environments.Add(renderapi.NewEnvironment(client.Environment{Id: envProdID, Name: "production", ProjectId: projectID}))
+	server.Environments.Add(renderapi.NewEnvironment(client.Environment{Id: envStagingID, Name: "staging", ProjectId: projectID}))
+
+	prodKV := seedKVInEnv(server, "key-value-not-unique-name", envProdID)
+	prodKV.Status = client.DatabaseStatusSuspended
+	stagingKV := seedKVInEnv(server, "key-value-not-unique-name", envStagingID)
+	stagingKV.Status = client.DatabaseStatusSuspended
+
+	result, err := executeKVResume(t, server, "key-value-not-unique-name", "--environment", "production", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Contains(t, result.Stdout, "Resumed")
+	assert.Contains(t, result.Stdout, prodKV.Id)
+	for _, kv := range server.KV.Instances {
+		if kv.Id == prodKV.Id {
+			assert.Equal(t, client.DatabaseStatusAvailable, kv.Status)
+		}
+		if kv.Id == stagingKV.Id {
+			assert.Equal(t, client.DatabaseStatusSuspended, kv.Status, "staging KV must not be resumed")
+		}
+	}
+}
+
+func TestKVResume_APIError_Surfaced(t *testing.T) {
+	// First nextError is consumed by Resolve's GET; surface from there to
+	// confirm failure propagates and no resume POST fires.
+	server := renderapi.NewServer(t)
+	kv := seedSuspendedKV(server, "my-cache")
+	server.KV.RespondWith(http.StatusInternalServerError)
+
+	_, err := executeKVResume(t, server, kv.Id, "--output", "text")
+	require.Error(t, err)
+	assert.Equal(t, client.DatabaseStatusSuspended, server.KV.Instances[0].Status, "API error must not flip status")
+	assert.False(t, server.HasRequest("POST", "/key-value/"+kv.Id+"/resume"))
+}

cmd/kvsuspend.go

@@ -0,0 +1,109 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/render-oss/cli/pkg/client"
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/keyvalue"
+	"github.com/render-oss/cli/pkg/resolve"
+	"github.com/render-oss/cli/pkg/text"
+	kvtypes "github.com/render-oss/cli/pkg/types/keyvalue"
+)
+
+var kvSuspendCmd = &cobra.Command{
+	Use:          "suspend <keyValueID|keyValueName>",
+	Short:        "Suspend a Key Value store instance",
+	Args:         cobra.ExactArgs(1),
+	SilenceUsage: true,
+	Long: `Suspend a Key Value store instance on Render.
+
+Without --confirm, this command previews what would be suspended and makes no
+changes. Pass --confirm to actually suspend the instance.
+
+The positional argument accepts either a Key Value ID (red-...) or a name.
+If the name matches more than one instance, narrow the search with
+--environment <id|name>, or pass the Key Value ID directly.
+
+Name lookup is scoped to your active workspace. If a name isn't found, switch
+workspaces with 'render workspace set <name|ID>' and try again, or pass the
+Key Value ID instead (which works across workspaces).`,
+	Example: `  # Preview suspension (no changes made)
+  render ea kv suspend red-abc123def456ghi789jkl0
+
+  # Suspend by ID
+  render ea kv suspend red-abc123def456ghi789jkl0 --confirm
+
+  # Suspend by name
+  render ea kv suspend my-cache --confirm
+
+  # Disambiguate a name that exists in multiple environments
+  render ea kv suspend my-cache --environment production --confirm
+
+  # JSON output
+  render ea kv suspend red-abc123def456ghi789jkl0 --confirm --output json`,
+}
+
+func init() {
+	kvSuspendCmd.Flags().String("environment", "",
+		"Environment ID or name (optional). Narrows name lookup when the same Key Value name exists in multiple environments.")
+
+	kvSuspendCmd.RunE = func(cmd *cobra.Command, args []string) error {
+		command.DefaultFormatNonInteractive(cmd)
+
+		var input kvtypes.KeyValueSuspendInput
+		if err := command.ParseCommand(cmd, args, &input); err != nil {
+			return err
+		}
+		input = kvtypes.NormalizeSuspendInput(input)
+		confirm := command.GetConfirmFromContext(cmd.Context())
+
+		loadData := func() (*keyvalue.SuspendResult, error) {
+			var project *client.Project
+			var env *client.Environment
+			if input.EnvironmentIDOrName != nil {
+				c, err := client.NewDefaultClient()
+				if err != nil {
+					return nil, err
+				}
+				scope, err := resolve.New(c).ResolveScopeInActiveWorkspace(cmd.Context(), resolve.ActiveWorkspaceScopeInput{
+					EnvironmentIDOrName: input.EnvironmentIDOrName,
+				})
+				if err != nil {
+					return nil, err
+				}
+				project = scope.Project
+				env = scope.Environment
+			}
+			kv, err := keyvalue.Resolve(cmd.Context(), input.IDOrName, project, env)
+			if err != nil {
+				return nil, err
+			}
+			if !confirm {
+				return &keyvalue.SuspendResult{KeyValue: kv, Suspended: false}, nil
+			}
+			if err := keyvalue.Suspend(cmd.Context(), kv.Id); err != nil {
+				return nil, err
+			}
+			post, err := keyvalue.Resolve(cmd.Context(), kv.Id, project, env)
+			if err != nil {
+				return nil, err
+			}
+			return &keyvalue.SuspendResult{KeyValue: post, Suspended: true}, nil
+		}
+
+		_, err := command.NonInteractive(cmd, loadData, formatSuspendTextOutput)
+		return err
+	}
+
+	kvCmd.AddCommand(kvSuspendCmd)
+}
+
+func formatSuspendTextOutput(r *keyvalue.SuspendResult) string {
+	if r.Suspended {
+		return "Suspended this Key Value:\n\n" + text.KeyValueDetail(r.KeyValue) + "\n"
+	}
+	return "This command would suspend this Key Value:\n\n" +
+		text.KeyValueDetail(r.KeyValue) +
+		"\n\nRe-run with --confirm to proceed\n"
+}