Command to delete a service (#488)

Adds `render services delete [idOrName]` command to delete a service from the command line.

- Only supports text, json, and yaml output modes (no interactive)
- Requires `--confirm` to proceed

GROW-2058

GitOrigin-RevId: a561fdad3de519be5c0b46997e5b75e73c41491f

Author: davidharting

cmd/root.go

@@ -180,6 +180,7 @@ func SetupCommands() error {
 	setupWorkflowCommands(deps)
 	setupLogCommands(deps)
 	setupWorkspaceCommands(deps)
+	servicesCmd.AddCommand(newServiceDeleteCmd(deps))
 	setupKVCommands(EarlyAccessCmd, deps)
 	setupPGCommands(EarlyAccessCmd, deps)
 	setupRootCmdPersistentRun(rootCmd, deps)

cmd/servicedelete.go

@@ -0,0 +1,99 @@
+package cmd
+
+import (
+	"github.com/spf13/cobra"
+
+	"github.com/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/config"
+	"github.com/render-oss/cli/pkg/dependencies"
+	servicepkg "github.com/render-oss/cli/pkg/service"
+	"github.com/render-oss/cli/pkg/text"
+)
+
+type serviceDeleteInput struct {
+	IDOrName string `cli:"arg:0"`
+}
+
+func newServiceDeleteCmd(deps *dependencies.Dependencies) *cobra.Command {
+	cmd := &cobra.Command{
+		Use:          "delete <serviceID|serviceName>",
+		Short:        "Delete a service",
+		Args:         cobra.ExactArgs(1),
+		SilenceUsage: true,
+		Long: `Delete a service on Render.
+
+Without --confirm, this command previews what would be deleted and makes no
+changes. Pass --confirm to actually delete the service.
+
+The positional argument accepts a service ID (including srv- or crn- IDs) or a
+name. Name lookup is scoped to your active workspace. If the name matches more
+than one service, pass the service ID directly.
+
+This command only runs non-interactively. If --output interactive is requested,
+it falls back to text output.`,
+		Example: `  # Preview deletion (no changes made)
+  render services delete srv-abc123def456ghi789jkl0
+
+  # Delete by ID
+  render services delete srv-abc123def456ghi789jkl0 --confirm
+
+  # Delete by name
+  render services delete my-api --confirm
+
+  # JSON output
+  render services delete srv-abc123def456ghi789jkl0 --confirm --output json`,
+	}
+
+	cmd.RunE = func(cmd *cobra.Command, args []string) error {
+		command.DefaultFormatNonInteractive(cmd)
+
+		var input serviceDeleteInput
+		if err := command.ParseCommand(cmd, args, &input); err != nil {
+			return err
+		}
+		confirm := command.GetConfirmFromContext(cmd.Context())
+
+		loadData := func() (*servicepkg.DeleteOut, error) {
+			if _, err := config.WorkspaceID(); err != nil {
+				return nil, err
+			}
+
+			repo := deps.ServiceRepo()
+			serviceID, err := repo.ResolveServiceIDFromNameOrID(cmd.Context(), input.IDOrName)
+			if err != nil {
+				return nil, err
+			}
+
+			model, err := deps.ServiceService().GetService(cmd.Context(), serviceID)
+			if err != nil {
+				return nil, err
+			}
+			out := servicepkg.NewDeleteOutFromModel(model)
+			out.Meta = servicepkg.DeleteOutMeta{
+				Deleted: confirm,
+			}
+			if confirm {
+				if err := repo.DeleteService(cmd.Context(), model.Service.Id); err != nil {
+					return nil, err
+				}
+			} else {
+				out.Meta.Message = "re-run with --confirm to delete"
+			}
+			return &out, nil
+		}
+
+		_, err := command.NonInteractive(cmd, loadData, serviceDeleteTextOutput)
+		return err
+	}
+
+	return cmd
+}
+
+func serviceDeleteTextOutput(r *servicepkg.DeleteOut) string {
+	if r.Meta.Deleted {
+		return "Deleted this service:\n\n" + text.ServiceDetail(&r.Data) + "\n"
+	}
+	return "This command would delete this service:\n\n" +
+		text.ServiceDetail(&r.Data) +
+		"\n\nRe-run with --confirm to proceed\n"
+}

cmd/servicedelete_test.go

@@ -0,0 +1,198 @@
+package cmd
+
+import (
+	"bytes"
+	"encoding/json"
+	"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/render-oss/cli/pkg/command"
+	"github.com/render-oss/cli/pkg/config"
+	"github.com/render-oss/cli/pkg/dependencies"
+	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+var serviceTestWorkspaceID = testids.WorkspaceID("active")
+
+const serviceTestWorkspaceName = "Test Workspace"
+
+func seedService(server *renderapi.Server, name string) *client.Service {
+	return server.Services.Add(renderapi.NewWebService(renderapi.WebServiceAttrs{
+		Service: renderapi.CommonServiceAttrs{
+			Name:    name,
+			OwnerID: serviceTestWorkspaceID,
+		},
+	}))
+}
+
+func executeServiceDelete(t *testing.T, server *renderapi.Server, extraArgs ...string) (CommandResult, error) {
+	t.Helper()
+	return executeServiceDeleteWithConfig(t, server, &config.Config{
+		Workspace:     serviceTestWorkspaceID,
+		WorkspaceName: serviceTestWorkspaceName,
+	}, extraArgs...)
+}
+
+func executeServiceDeleteWithoutActiveWorkspace(t *testing.T, server *renderapi.Server, extraArgs ...string) (CommandResult, error) {
+	t.Helper()
+	return executeServiceDeleteWithConfig(t, server, &config.Config{}, extraArgs...)
+}
+
+func executeServiceDeleteWithConfig(t *testing.T, server *renderapi.Server, cfg *config.Config, extraArgs ...string) (CommandResult, error) {
+	t.Helper()
+
+	server.Owners.Add(renderapi.NewOwner(client.Owner{Id: serviceTestWorkspaceID, Name: serviceTestWorkspaceName}))
+	t.Setenv("RENDER_CLI_CONFIG_PATH", newTestConfigPath(t))
+	t.Setenv("RENDER_HOST", server.URL())
+	t.Setenv("RENDER_API_KEY", "test-api-key")
+	t.Setenv("RENDER_WORKSPACE", "")
+	if cfg != nil {
+		require.NoError(t, cfg.Persist())
+	}
+
+	c, err := client.NewClientWithResponses(server.URL())
+	require.NoError(t, err)
+	deps := dependencies.New(c)
+	deps.DetectRuntimeSignals = func() (command.RuntimeSignals, error) {
+		return command.RuntimeSignals{
+			StdinTTY:  false,
+			StdoutTTY: false,
+			StderrTTY: false,
+		}, nil
+	}
+
+	root := newRootCmd()
+	services := cobraServicesCommand()
+	services.AddCommand(newServiceDeleteCmd(deps))
+	root.AddCommand(services)
+	setupRootCmdPersistentRun(root, deps)
+
+	var stdout, stderr bytes.Buffer
+	root.SetOut(&stdout)
+	root.SetErr(&stderr)
+	root.SetArgs(append([]string{"services", "delete"}, extraArgs...))
+
+	execErr := root.Execute()
+	return CommandResult{Stdout: stdout.String(), Stderr: stderr.String()}, execErr
+}
+
+func cobraServicesCommand() *cobra.Command {
+	return &cobra.Command{
+		Use:     "services",
+		Aliases: []string{"service"},
+	}
+}
+
+func TestServiceDelete_PreviewByID_DoesNotDelete(t *testing.T) {
+	server := renderapi.NewServer(t)
+	svc := seedService(server, "my-api")
+
+	result, err := executeServiceDelete(t, server, svc.Id, "--output", "text")
+	require.NoError(t, err)
+
+	assert.Len(t, server.Services.Instances, 1, "preview must not delete")
+	assert.False(t, server.HasDeleteRequest(), "no DELETE call should be made in preview")
+	assert.Contains(t, result.Stdout, "would delete")
+	assert.Contains(t, result.Stdout, "--confirm")
+	assert.Contains(t, result.Stdout, svc.Id)
+	assert.Contains(t, result.Stdout, "my-api")
+}
+
+func TestServiceDelete_ConfirmByName_Deletes(t *testing.T) {
+	server := renderapi.NewServer(t)
+	svc := seedService(server, "by-name-api")
+
+	result, err := executeServiceDelete(t, server, "by-name-api", "--confirm", "--output", "text")
+	require.NoError(t, err)
+
+	assert.Empty(t, server.Services.Instances)
+	assert.True(t, server.HasRequest("DELETE", "/services/"+svc.Id))
+	assert.Contains(t, result.Stdout, "Deleted")
+	assert.Contains(t, result.Stdout, svc.Id)
+}
+
+func TestServiceDelete_DatastoreIDsAreNotServices(t *testing.T) {
+	server := renderapi.NewServer(t)
+	pg := server.Postgres.Add(renderapi.NewPostgres(client.PostgresDetail{
+		Name:  "app-db",
+		Owner: client.Owner{Id: serviceTestWorkspaceID},
+	}))
+
+	_, err := executeServiceDelete(t, server, pg.Id, "--confirm", "--output", "text")
+	require.Error(t, err)
+
+	assert.Contains(t, err.Error(), "No service named")
+	assert.Contains(t, err.Error(), serviceTestWorkspaceName)
+	assert.Len(t, server.Postgres.Instances, 1)
+	assert.False(t, server.HasDeleteRequest())
+}
+
+func TestServiceDelete_NameCollision_Errors(t *testing.T) {
+	server := renderapi.NewServer(t)
+	seedService(server, "not-unique")
+	seedService(server, "not-unique")
+
+	_, err := executeServiceDelete(t, server, "not-unique", "--confirm", "--output", "text")
+	require.Error(t, err)
+
+	assert.Contains(t, err.Error(), "Multiple services found")
+	assert.Len(t, server.Services.Instances, 2, "no delete on ambiguity")
+	assert.False(t, server.HasDeleteRequest())
+}
+
+func TestServiceDelete_JSONOutput_AfterConfirm(t *testing.T) {
+	server := renderapi.NewServer(t)
+	svc := seedService(server, "json-api")
+
+	result, err := executeServiceDelete(t, server, svc.Id, "--confirm", "--output", "json")
+	require.NoError(t, err)
+	assert.Empty(t, server.Services.Instances)
+
+	var body map[string]any
+	require.NoError(t, json.Unmarshal([]byte(result.Stdout), &body))
+	require.Len(t, body, 2)
+
+	data := requireSubMap(t, body, "data")
+	meta := requireSubMap(t, body, "meta")
+
+	assert.Equal(t, svc.Id, data["id"])
+	assert.Equal(t, "json-api", data["name"])
+	assert.Equal(t, serviceTestWorkspaceID, data["ownerId"])
+	assert.Equal(t, string(client.WebService), data["type"])
+	assert.Contains(t, data, "serviceDetails")
+	assert.Equal(t, true, meta["deleted"])
+}
+
+func TestServiceDelete_JSONOutput_PreviewIncludesConfirmMessage(t *testing.T) {
+	server := renderapi.NewServer(t)
+	svc := seedService(server, "json-api")
+
+	result, err := executeServiceDelete(t, server, svc.Id, "--output", "json")
+	require.NoError(t, err)
+	assert.Len(t, server.Services.Instances, 1, "preview must not delete")
+
+	var body map[string]any
+	require.NoError(t, json.Unmarshal([]byte(result.Stdout), &body))
+
+	data := requireSubMap(t, body, "data")
+	meta := requireSubMap(t, body, "meta")
+	assert.Equal(t, svc.Id, data["id"])
+	assert.Equal(t, false, meta["deleted"])
+	assert.Equal(t, "re-run with --confirm to delete", meta["message"])
+}
+
+func TestServiceDelete_RequiresActiveWorkspace(t *testing.T) {
+	server := renderapi.NewServer(t)
+	svc := seedService(server, "my-api")
+
+	_, err := executeServiceDeleteWithoutActiveWorkspace(t, server, svc.Id, "--confirm", "--output", "text")
+	require.Error(t, err)
+
+	assert.Contains(t, err.Error(), "workspace")
+	assert.Len(t, server.Services.Instances, 1)
+	assert.False(t, server.HasDeleteRequest())
+}

cmd/testhelpers_test.go

@@ -4,6 +4,7 @@ import (
 	"os"
 	"testing"
 
+	"github.com/render-oss/cli/internal/testrequire"
 	"github.com/stretchr/testify/require"
 )
 
@@ -26,9 +27,7 @@ func newTestConfigPath(t *testing.T) string {
 // key is absent or the value is not a map[string]any.
 func requireSubMap(t *testing.T, body map[string]any, key string) map[string]any {
 	t.Helper()
-	require.Contains(t, body, key, "expected %q", key)
-	require.IsType(t, map[string]any{}, body[key], "expected %q to contain a map", key)
-	return body[key].(map[string]any)
+	return testrequire.SubMap(t, body, key)
 }
 
 // requireSubSlice returns the nested slice stored at key, failing the test if

internal/fakes/renderapi/server.go

@@ -317,6 +317,16 @@ func (s *Server) HasRequest(method, uriSubstring string) bool {
 	return false
 }
 
+// HasDeleteRequest returns true if any recorded request used the DELETE method.
+func (s *Server) HasDeleteRequest() bool {
+	for _, r := range s.Requests {
+		if r.Method == http.MethodDelete {
+			return true
+		}
+	}
+	return false
+}
+
 // NewServer starts a fake Render API server covering all routes used by cmd-level tests.
 // The server is closed automatically when t completes. Seed state via server.Owners.Add(), etc.
 func NewServer(t *testing.T) *Server {

internal/testrequire/maps.go

@@ -0,0 +1,16 @@
+package testrequire
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// SubMap returns the nested map stored at key, failing the test if the key is
+// absent or the value is not a map[string]any.
+func SubMap(t *testing.T, body map[string]any, key string) map[string]any {
+	t.Helper()
+	require.Contains(t, body, key, "expected %q", key)
+	require.IsType(t, map[string]any{}, body[key], "expected %q to contain a map", key)
+	return body[key].(map[string]any)
+}