coder/cli/templatepresets_test.go

package cli_test

import (
	"fmt"
	"testing"

	"github.com/stretchr/testify/require"

	"github.com/coder/coder/v2/cli/clitest"
	"github.com/coder/coder/v2/coderd/coderdtest"
	"github.com/coder/coder/v2/codersdk"
	"github.com/coder/coder/v2/provisioner/echo"
	"github.com/coder/coder/v2/provisionersdk/proto"
	"github.com/coder/coder/v2/pty/ptytest"
	"github.com/coder/coder/v2/testutil"
)

func TestTemplatePresets(t *testing.T) {
	t.Parallel()

	t.Run("NoPresets", func(t *testing.T) {
		t.Parallel()

		client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})
		owner := coderdtest.CreateFirstUser(t, client)
		member, _ := coderdtest.CreateAnotherUser(t, client, owner.OrganizationID)

		// Given: a template version without presets
		version := coderdtest.CreateTemplateVersion(t, client, owner.OrganizationID, templateWithPresets([]*proto.Preset{}))
		_ = coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)
		template := coderdtest.CreateTemplate(t, client, owner.OrganizationID, version.ID)

		// When: listing presets for that template
		inv, root := clitest.New(t, "templates", "presets", "list", template.Name)
		clitest.SetupConfig(t, member, root)

		pty := ptytest.New(t).Attach(inv)
		doneChan := make(chan struct{})
		var runErr error
		go func() {
			defer close(doneChan)
			runErr = inv.Run()
		}()
		<-doneChan
		require.NoError(t, runErr)

		// Should return a message when no presets are found for the given template and version.
		notFoundMessage := fmt.Sprintf("No presets found for template %q and template-version %q.", template.Name, version.Name)
		pty.ExpectRegexMatch(notFoundMessage)
	})

	t.Run("ListsPresetsForDefaultTemplateVersion", func(t *testing.T) {
		t.Parallel()

		client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})
		owner := coderdtest.CreateFirstUser(t, client)
		member, _ := coderdtest.CreateAnotherUser(t, client, owner.OrganizationID)

		// Given: an active template version that includes presets
		presets := []*proto.Preset{
			{
				Name: "preset-multiple-params",
				Parameters: []*proto.PresetParameter{
					{
						Name:  "k1",
						Value: "v1",
					}, {
						Name:  "k2",
						Value: "v2",
					},
				},
			},
			{
				Name:    "preset-default",
				Default: true,
				Parameters: []*proto.PresetParameter{
					{
						Name:  "k1",
						Value: "v2",
					},
				},
				Prebuild: &proto.Prebuild{
					Instances: 0,
				},
			},
			{
				Name:       "preset-prebuilds",
				Parameters: []*proto.PresetParameter{},
				Prebuild: &proto.Prebuild{
					Instances: 2,
				},
			},
		}
		version := coderdtest.CreateTemplateVersion(t, client, owner.OrganizationID, templateWithPresets(presets))
		_ = coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)
		template := coderdtest.CreateTemplate(t, client, owner.OrganizationID, version.ID)
		require.Equal(t, version.ID, template.ActiveVersionID)

		// When: listing presets for that template
		inv, root := clitest.New(t, "templates", "presets", "list", template.Name)
		clitest.SetupConfig(t, member, root)

		pty := ptytest.New(t).Attach(inv)
		doneChan := make(chan struct{})
		var runErr error
		go func() {
			defer close(doneChan)
			runErr = inv.Run()
		}()

		<-doneChan
		require.NoError(t, runErr)

		// Should: return the active version's presets sorted by name
		message := fmt.Sprintf("Showing presets for template %q and template version %q.", template.Name, version.Name)
		pty.ExpectMatch(message)
		pty.ExpectRegexMatch(`preset-default\s+k1=v2\s+true\s+0`)
		// The parameter order is not guaranteed in the output, so we match both possible orders
		pty.ExpectRegexMatch(`preset-multiple-params\s+(k1=v1,k2=v2)|(k2=v2,k1=v1)\s+false\s+-`)
		pty.ExpectRegexMatch(`preset-prebuilds\s+\s+false\s+2`)
	})

	t.Run("ListsPresetsForSpecifiedTemplateVersion", func(t *testing.T) {
		t.Parallel()

		ctx := testutil.Context(t, testutil.WaitMedium)

		client := coderdtest.New(t, &coderdtest.Options{IncludeProvisionerDaemon: true})
		owner := coderdtest.CreateFirstUser(t, client)
		member, _ := coderdtest.CreateAnotherUser(t, client, owner.OrganizationID)

		// Given: a template with an active version that has no presets,
		// and another template version that includes presets
		presets := []*proto.Preset{
			{
				Name: "preset-multiple-params",
				Parameters: []*proto.PresetParameter{
					{
						Name:  "k1",
						Value: "v1",
					}, {
						Name:  "k2",
						Value: "v2",
					},
				},
			},
			{
				Name:    "preset-default",
				Default: true,
				Parameters: []*proto.PresetParameter{
					{
						Name:  "k1",
						Value: "v2",
					},
				},
				Prebuild: &proto.Prebuild{
					Instances: 0,
				},
			},
			{
				Name:       "preset-prebuilds",
				Parameters: []*proto.PresetParameter{},
				Prebuild: &proto.Prebuild{
					Instances: 2,
				},
			},
		}
		// Given: first template version with presets
		version := coderdtest.CreateTemplateVersion(t, client, owner.OrganizationID, templateWithPresets(presets))
		_ = coderdtest.AwaitTemplateVersionJobCompleted(t, client, version.ID)
		template := coderdtest.CreateTemplate(t, client, owner.OrganizationID, version.ID)
		// Given: second template version without presets
		activeVersion := coderdtest.UpdateTemplateVersion(t, client, owner.OrganizationID, templateWithPresets([]*proto.Preset{}), template.ID)
		_ = coderdtest.AwaitTemplateVersionJobCompleted(t, client, activeVersion.ID)
		// Given: second template version is the active version
		err := client.UpdateActiveTemplateVersion(ctx, template.ID, codersdk.UpdateActiveTemplateVersion{
			ID: activeVersion.ID,
		})
		require.NoError(t, err)
		updatedTemplate, err := client.Template(ctx, template.ID)
		require.NoError(t, err)
		require.Equal(t, activeVersion.ID, updatedTemplate.ActiveVersionID)
		// Given: template has two versions
		templateVersions, err := client.TemplateVersionsByTemplate(ctx, codersdk.TemplateVersionsByTemplateRequest{
			TemplateID: updatedTemplate.ID,
		})
		require.NoError(t, err)
		require.Len(t, templateVersions, 2)

		// When: listing presets for a specific template and its specified version
		inv, root := clitest.New(t, "templates", "presets", "list", updatedTemplate.Name, "--template-version", version.Name)
		clitest.SetupConfig(t, member, root)

		pty := ptytest.New(t).Attach(inv)
		doneChan := make(chan struct{})
		var runErr error
		go func() {
			defer close(doneChan)
			runErr = inv.Run()
		}()

		<-doneChan
		require.NoError(t, runErr)

		// Should: return the specified version's presets sorted by name
		message := fmt.Sprintf("Showing presets for template %q and template version %q.", template.Name, version.Name)
		pty.ExpectMatch(message)
		pty.ExpectRegexMatch(`preset-default\s+k1=v2\s+true\s+0`)
		// The parameter order is not guaranteed in the output, so we match both possible orders
		pty.ExpectRegexMatch(`preset-multiple-params\s+(k1=v1,k2=v2)|(k2=v2,k1=v1)\s+false\s+-`)
		pty.ExpectRegexMatch(`preset-prebuilds\s+\s+false\s+2`)
	})
}

func templateWithPresets(presets []*proto.Preset) *echo.Responses {
	return &echo.Responses{
		Parse: echo.ParseComplete,
		ProvisionPlan: []*proto.Response{
			{
				Type: &proto.Response_Plan{
					Plan: &proto.PlanComplete{
						Presets: presets,
					},
				},
			},
		},
	}
}