Refactor parameters to enable schema matching

coder · kylecarbs · Feb 12, 2022 · Feb 10, 2022 · Feb 10, 2022 · Feb 10, 2022
commit 94eb484655a33d5e5d6899886330e84c83eae9c3
diff --git a/cli/clitest/clitest.go b/cli/clitest/clitest.go
@@ -2,13 +2,18 @@ package clitest
 
 import (
 	"bufio"
+	"context"
 	"io"
 	"testing"
 
 	"github.com/spf13/cobra"
+	"github.com/stretchr/testify/require"
 
 	"github.com/coder/coder/cli"
 	"github.com/coder/coder/cli/config"
+	"github.com/coder/coder/coderd"
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/coder/coder/codersdk"
 )
 
 func New(t *testing.T, args ...string) (*cobra.Command, config.Root) {
@@ -19,6 +24,20 @@ func New(t *testing.T, args ...string) (*cobra.Command, config.Root) {
 	return cmd, root
 }
 
+func CreateInitialUser(t *testing.T, client *codersdk.Client, root config.Root) coderd.CreateInitialUserRequest {
+	user := coderdtest.CreateInitialUser(t, client)
+	resp, err := client.LoginWithPassword(context.Background(), coderd.LoginWithPasswordRequest{
+		Email:    user.Email,
+		Password: user.Password,
+	})
+	require.NoError(t, err)
+	err = root.Session().Write(resp.SessionToken)
+	require.NoError(t, err)
+	err = root.URL().Write(client.URL.String())
+	require.NoError(t, err)
+	return user
+}
+
 func StdoutLogs(t *testing.T) io.Writer {
 	reader, writer := io.Pipe()
 	scanner := bufio.NewScanner(reader)

diff --git a/cli/projectcreate.go b/cli/projectcreate.go
@@ -21,7 +21,10 @@ import (
 )
 
 func projectCreate() *cobra.Command {
-	return &cobra.Command{
+	var (
+		directory string
+	)
+	cmd := &cobra.Command{
 		Use:   "create",
 		Short: "Create a project from the current directory",
 		RunE: func(cmd *cobra.Command, args []string) error {
@@ -33,23 +36,17 @@ func projectCreate() *cobra.Command {
 			if err != nil {
 				return err
 			}
-
-			workingDir, err := os.Getwd()
-			if err != nil {
-				return err
-			}
-
 			_, err = runPrompt(cmd, &promptui.Prompt{
 				Default:   "y",
 				IsConfirm: true,
-				Label:     fmt.Sprintf("Set up %s in your organization?", color.New(color.FgHiCyan).Sprintf("%q", workingDir)),
+				Label:     fmt.Sprintf("Set up %s in your organization?", color.New(color.FgHiCyan).Sprintf("%q", directory)),
 			})
 			if err != nil {
 				return err
 			}
 
 			name, err := runPrompt(cmd, &promptui.Prompt{
-				Default: filepath.Base(workingDir),
+				Default: filepath.Base(directory),
 				Label:   "What's your project's name?",
 				Validate: func(s string) error {
 					_, err = client.Project(cmd.Context(), organization.Name, s)
@@ -63,12 +60,12 @@ func projectCreate() *cobra.Command {
 				return err
 			}
 
-			spin := spinner.New(spinner.CharSets[0], 50*time.Millisecond)
+			spin := spinner.New(spinner.CharSets[0], 25*time.Millisecond)
 			spin.Suffix = " Uploading current directory..."
 			spin.Start()
 			defer spin.Stop()
 
-			bytes, err := tarDirectory(workingDir)
+			bytes, err := tarDirectory(directory)
 			if err != nil {
 				return err
 			}
@@ -84,6 +81,12 @@ func projectCreate() *cobra.Command {
 				Provisioner:   database.ProvisionerTypeTerraform,
 				// SkipResources on first import to detect variables defined by the project.
 				SkipResources: true,
+				// ParameterValues: []coderd.CreateParameterValueRequest{{
+				// 	Name:              "aws_access_key",
+				// 	SourceValue:       "tomato",
+				// 	SourceScheme:      database.ParameterSourceSchemeData,
+				// 	DestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
+				// }},
 			})
 			if err != nil {
 				return err
@@ -102,19 +105,85 @@ func projectCreate() *cobra.Command {
 				_, _ = fmt.Fprintf(cmd.OutOrStdout(), "%s %s\n", color.HiGreenString("[parse]"), log.Output)
 			}
 
+			_, _ = fmt.Fprintf(cmd.OutOrStdout(), "Parsed project source... displaying parameters:")
+
 			schemas, err := client.ProvisionerJobParameterSchemas(cmd.Context(), organization.Name, job.ID)
 			if err != nil {
 				return err
 			}
 
+			values, err := client.ProvisionerJobParameterValues(cmd.Context(), organization.Name, job.ID)
+			if err != nil {
+				return err
+			}
+			valueBySchemaID := map[string]coderd.ComputedParameterValue{}
+			for _, value := range values {
+				valueBySchemaID[value.SchemaID.String()] = value
+			}
+
 			for _, schema := range schemas {
-				fmt.Printf("Schema: %+v\n", schema)
+				if value, ok := valueBySchemaID[schema.ID.String()]; ok {
+					fmt.Printf("Value for: %s %s\n", value.Name, value.SourceValue)
+					continue
+				}
+				fmt.Printf("No value for: %s\n", schema.Name)
 			}
 
+			// schemas, err := client.ProvisionerJobParameterSchemas(cmd.Context(), organization.Name, job.ID)
+			// if err != nil {
+			// 	return err
+			// }
+			// _, _ = fmt.Fprintf(cmd.OutOrStdout(), "\n  %s\n\n", color.HiBlackString("Parameters"))
+
+			// for _, param := range params {
+			// 	if param.Value == nil {
+			// 		_, _ = fmt.Fprintf(cmd.OutOrStdout(), "    %s = must be set\n", color.HiRedString(param.Schema.Name))
+			// 		continue
+			// 	}
+			// 	value := param.Value.DestinationValue
+			// 	if !param.Schema.RedisplayValue {
+			// 		value = "<redacted>"
+			// 	}
+			// 	output := fmt.Sprintf("    %s = %s", color.HiGreenString(param.Value.SourceValue), color.CyanString(value))
+			// 	param.Value.DefaultSourceValue = false
+			// 	param.Value.Scope = database.ParameterScopeOrganization
+			// 	param.Value.ScopeID = organization.ID
+			// 	if param.Value.DefaultSourceValue {
+			// 		output += " (default value)"
+			// 	} else {
+			// 		output += fmt.Sprintf(" (inherited from %s)", param.Value.Scope)
+			// 	}
+			// 	root := treeprint.NewWithRoot(output)
+			// 	root.AddNode(color.HiBlackString("Description") + "\n" + param.Schema.Description)
+			// 	fmt.Fprintln(cmd.OutOrStdout(), strings.Join(strings.Split(root.String(), "\n"), "\n    "))
+			// }
+
+			// for _, param := range params {
+			// 	if param.Value != nil {
+			// 		continue
+			// 	}
+
+			// 	value, err := runPrompt(cmd, &promptui.Prompt{
+			// 		Label: "Specify value for " + color.HiCyanString(param.Schema.Name),
+			// 		Validate: func(s string) error {
+			// 			// param.Schema.Vali
+			// 			return nil
+			// 		},
+			// 	})
+			// 	if err != nil {
+			// 		continue
+			// 	}
+			// 	fmt.Printf(": %s\n", value)
+			// }
+
 			_, _ = fmt.Fprintf(cmd.OutOrStdout(), "Create project %q!\n", name)
 			return nil
 		},
 	}
+	currentDirectory, _ := os.Getwd()
+	cmd.Flags().StringVarP(&directory, "directory", "d", currentDirectory, "Specify the directory to create from")
+
+	return cmd
 }
 
 func tarDirectory(directory string) ([]byte, error) {

diff --git a/cli/projectcreate_test.go b/cli/projectcreate_test.go
@@ -0,0 +1,42 @@
+package cli_test
+
+import (
+	"testing"
+
+	"github.com/Netflix/go-expect"
+	"github.com/coder/coder/cli/clitest"
+	"github.com/coder/coder/coderd/coderdtest"
+	"github.com/stretchr/testify/require"
+)
+
+func TestProjectCreate(t *testing.T) {
+	t.Parallel()
+	t.Run("InitialUserTTY", func(t *testing.T) {
+		t.Parallel()
+		console, err := expect.NewConsole(expect.WithStdout(clitest.StdoutLogs(t)))
+		require.NoError(t, err)
+		client := coderdtest.New(t)
+		directory := t.TempDir()
+		cmd, root := clitest.New(t, "projects", "create", "--directory", directory)
+		_ = clitest.CreateInitialUser(t, client, root)
+		cmd.SetIn(console.Tty())
+		cmd.SetOut(console.Tty())
+		go func() {
+			err := cmd.Execute()
+			require.NoError(t, err)
+		}()
+
+		matches := []string{
+			"organization?", "y",
+			"name?", "",
+		}
+		for i := 0; i < len(matches); i += 2 {
+			match := matches[i]
+			value := matches[i+1]
+			_, err = console.ExpectString(match)
+			require.NoError(t, err)
+			_, err = console.SendLine(value)
+			require.NoError(t, err)
+		}
+	})
+}
diff --git a/cli/projects.go b/cli/projects.go
@@ -7,8 +7,9 @@ import (
 
 func projects() *cobra.Command {
 	cmd := &cobra.Command{
-		Use:  "projects",
-		Long: "Testing something",
+		Use:     "projects",
+		Aliases: []string{"project"},
+		Long:    "Testing something",
 		Example: `
   - Create a project for developers to create workspaces
 

diff --git a/coderd/coderd.go b/coderd/coderd.go
@@ -121,7 +121,8 @@ func New(options *Options) http.Handler {
 				r.Route("/{provisionerjob}", func(r chi.Router) {
 					r.Use(httpmw.ExtractProvisionerJobParam(options.Database))
 					r.Get("/", api.provisionerJobByOrganization)
-					r.Get("/parameters", api.provisionerJobParametersByID)
+					r.Get("/schemas", api.provisionerJobParameterSchemasByID)
+					r.Get("/computed", api.provisionerJobComputedParametersByID)
 					r.Get("/logs", api.provisionerJobLogsByID)
 				})
 			})

diff --git a/coderd/parameter/compute_test.go b/coderd/parameter/compute_test.go
@@ -201,4 +201,22 @@ func TestCompute(t *testing.T) {
 		require.Len(t, computed, 1)
 		require.Equal(t, false, computed[0].DefaultSourceValue)
 	})
+
+	t.Run("HideRedisplay", func(t *testing.T) {
+		t.Parallel()
+		db := databasefake.New()
+		scope := generateScope()
+		_ = generateParameter(t, db, parameterOptions{
+			ProjectImportJobID:       scope.ProjectImportJobID,
+			DefaultDestinationScheme: database.ParameterDestinationSchemeProvisionerVariable,
+		})
+		computed, err := parameter.Compute(context.Background(), db, scope, &parameter.ComputeOptions{
+			HideRedisplayValues: true,
+		})
+		require.NoError(t, err)
+		require.Len(t, computed, 1)
+		computedValue := computed[0]
+		require.True(t, computedValue.DefaultSourceValue)
+		require.Equal(t, computedValue.SourceValue, "")
+	})
 }