Add support for setting default application in config

7 files changed, 67 insertions, 35 deletions

diff --git a/client/go/cmd/cert.go b/client/go/cmd/cert.go
index 530981d08cd..a1d4be6b1f5 100644
--- a/client/go/cmd/cert.go
+++ b/client/go/cmd/cert.go
@@ -19,7 +19,7 @@ var overwriteCertificate bool
 func init() {
 	rootCmd.AddCommand(certCmd)
 	certCmd.Flags().BoolVarP(&overwriteCertificate, "force", "f", false, "Force overwrite of existing certificate and private key")
-	certCmd.PersistentFlags().StringVarP(&applicationArg, applicationFlag, "a", "", "The application owning this certificate")
+	addApplicationFlag(certCmd)
 	certCmd.MarkPersistentFlagRequired(applicationFlag)
 }
 
@@ -38,11 +38,10 @@ var certCmd = &cobra.Command{
 			fatalIfErr(err)
 		}
 
-		app, err := vespa.ApplicationFromString(applicationArg)
-		fatalIfErr(err)
+		app := getApplication()
 		pkg, err := vespa.ApplicationPackageFrom(path)
 		fatalIfErr(err)
-		configDir, err := configDir(app.String())
+		configDir, err := configDir(app)
 		fatalIfErr(err)
 
 		securityDir := filepath.Join(pkg.Path, "security")
diff --git a/client/go/cmd/command_tester.go b/client/go/cmd/command_tester.go
index cbd169dfb4b..46c37e0fbd2 100644
--- a/client/go/cmd/command_tester.go
+++ b/client/go/cmd/command_tester.go
@@ -20,7 +20,7 @@ import (
 	"github.com/vespa-engine/vespa/util"
 )
 
-func executeCommand(t *testing.T, client *mockHttpClient, args []string, moreArgs []string) (standardout string) {
+func executeCommand(t *testing.T, client *mockHttpClient, args []string, moreArgs []string) string {
 	if client != nil {
 		util.ActiveHttpClient = client
 	}
@@ -30,13 +30,16 @@ func executeCommand(t *testing.T, client *mockHttpClient, args []string, moreArg
 
 	// Use a separate config dir for each test
 	os.Setenv("VESPA_CLI_HOME", t.TempDir())
-	viper.Reset() // Reset config in case tests manipulate it
+	if len(args) > 0 && args[0] != "config" {
+		viper.Reset() // Reset config unless we're testing the config sub-command
+	}
 
 	// Reset to default target - persistent flags in Cobra persists over tests
 	log.SetOutput(bytes.NewBufferString(""))
 	rootCmd.SetArgs([]string{"status", "-t", "local"})
 	rootCmd.Execute()
 
+	// Capture stdout and execute command
 	b := bytes.NewBufferString("")
 	log.SetOutput(b)
 	rootCmd.SetArgs(append(args, moreArgs...))
diff --git a/client/go/cmd/config.go b/client/go/cmd/config.go
index 3b28a51d544..f03b0a16606 100644
--- a/client/go/cmd/config.go
+++ b/client/go/cmd/config.go
@@ -14,6 +14,7 @@ import (
 	"github.com/spf13/cobra"
 	"github.com/spf13/viper"
 	"github.com/vespa-engine/vespa/util"
+	"github.com/vespa-engine/vespa/vespa"
 )
 
 const (
@@ -21,13 +22,12 @@ const (
 	configType = "yaml"
 )
 
-var flagToConfigBindings map[string][]*cobra.Command
+var flagToConfigBindings map[string][]*cobra.Command = make(map[string][]*cobra.Command)
 
 func init() {
 	rootCmd.AddCommand(configCmd)
 	configCmd.AddCommand(setConfigCmd)
 	configCmd.AddCommand(getConfigCmd)
-	flagToConfigBindings = make(map[string][]*cobra.Command)
 }
 
 var configCmd = &cobra.Command{
@@ -122,19 +122,25 @@ func getOption(option string) (string, error) {
 }
 
 func setOption(option, value string) error {
-	if option != "target" {
-		return fmt.Errorf("invalid option: %q", option)
-	}
-	switch value {
-	case "local", "cloud":
-		viper.Set(option, value)
-		return nil
-	}
-	if strings.HasPrefix(value, "http://") || strings.HasPrefix(value, "https://") {
+	switch option {
+	case targetFlag:
+		switch value {
+		case "local", "cloud":
+			viper.Set(option, value)
+			return nil
+		}
+		if strings.HasPrefix(value, "http://") || strings.HasPrefix(value, "https://") {
+			viper.Set(option, value)
+			return nil
+		}
+	case applicationFlag:
+		if _, err := vespa.ApplicationFromString(value); err != nil {
+			return err
+		}
 		viper.Set(option, value)
 		return nil
 	}
-	return fmt.Errorf("invalid value for option %q: %q", option, value)
+	return fmt.Errorf("invalid option or value: %q: %q", option, value)
 }
 
 func writeConfig() {
diff --git a/client/go/cmd/config_test.go b/client/go/cmd/config_test.go
index b51e7f012e5..a9849d105bb 100644
--- a/client/go/cmd/config_test.go
+++ b/client/go/cmd/config_test.go
@@ -7,11 +7,17 @@ import (
 )
 
 func TestConfig(t *testing.T) {
-	assert.Equal(t, "invalid option: \"foo\"\n", executeCommand(t, nil, []string{"config", "set", "foo", "bar"}, nil))
+	assert.Equal(t, "invalid option or value: \"foo\": \"bar\"\n", executeCommand(t, nil, []string{"config", "set", "foo", "bar"}, nil))
 	assert.Equal(t, "foo = <unset>\n", executeCommand(t, nil, []string{"config", "get", "foo"}, nil))
 	assert.Equal(t, "target = local\n", executeCommand(t, nil, []string{"config", "get", "target"}, nil))
 	assert.Equal(t, "", executeCommand(t, nil, []string{"config", "set", "target", "cloud"}, nil))
-	assert.Equal(t, "", executeCommand(t, nil, []string{"config", "set", "target", "local"}, nil))
+	assert.Equal(t, "target = cloud\n", executeCommand(t, nil, []string{"config", "get", "target"}, nil))
 	assert.Equal(t, "", executeCommand(t, nil, []string{"config", "set", "target", "http://127.0.0.1:8080"}, nil))
 	assert.Equal(t, "", executeCommand(t, nil, []string{"config", "set", "target", "https://127.0.0.1"}, nil))
+	assert.Equal(t, "target = https://127.0.0.1\n", executeCommand(t, nil, []string{"config", "get", "target"}, nil))
+
+	assert.Equal(t, "invalid application: \"foo\"\n", executeCommand(t, nil, []string{"config", "set", "application", "foo"}, nil))
+	assert.Equal(t, "application = <unset>\n", executeCommand(t, nil, []string{"config", "get", "application"}, nil))
+	assert.Equal(t, "", executeCommand(t, nil, []string{"config", "set", "application", "t1.a1.i1"}, nil))
+	assert.Equal(t, "application = t1.a1.i1\n", executeCommand(t, nil, []string{"config", "get", "application"}, nil))
 }
diff --git a/client/go/cmd/deploy.go b/client/go/cmd/deploy.go
index 9428d7ca6b3..5691f453832 100644
--- a/client/go/cmd/deploy.go
+++ b/client/go/cmd/deploy.go
@@ -14,13 +14,11 @@ import (
 )
 
 const (
-	zoneFlag        = "zone"
-	applicationFlag = "application"
+	zoneFlag = "zone"
 )
 
 var (
-	zoneArg        string
-	applicationArg string
+	zoneArg string
 )
 
 func init() {
@@ -28,11 +26,11 @@ func init() {
 	rootCmd.AddCommand(prepareCmd)
 	rootCmd.AddCommand(activateCmd)
 	addTargetFlag(deployCmd)
+	addApplicationFlag(deployCmd)
 	addTargetFlag(prepareCmd)
 	addTargetFlag(activateCmd)
 
 	deployCmd.PersistentFlags().StringVarP(&zoneArg, zoneFlag, "z", "dev.aws-us-east-1c", "The zone to use for deployment")
-	deployCmd.PersistentFlags().StringVarP(&applicationArg, applicationFlag, "a", "", "The application name to use for deployment")
 }
 
 var deployCmd = &cobra.Command{
@@ -42,7 +40,7 @@ var deployCmd = &cobra.Command{
 	Run: func(cmd *cobra.Command, args []string) {
 		d := vespa.Deployment{
 			ApplicationSource: applicationSource(args),
-			TargetType:        targetArg,
+			TargetType:        getTargetType(),
 			TargetURL:         deployTarget(),
 		}
 		if d.IsCloud() {
@@ -52,12 +50,12 @@ var deployCmd = &cobra.Command{
 				errorWithHint(err, "Zones have the format <env>.<region>.")
 				return
 			}
-			d.Application, err = vespa.ApplicationFromString(applicationArg)
+			d.Application, err = vespa.ApplicationFromString(getApplication())
 			if err != nil {
 				errorWithHint(err, "Applications have the format <tenant>.<application-name>.<instance-name>")
 				return
 			}
-			d.APIKey, err = loadApiKey(applicationArg)
+			d.APIKey, err = loadApiKey(getApplication())
 			if err != nil {
 				errorWithHint(err, "Deployment to cloud requires an API key. Try 'vespa api-key'")
 				return
diff --git a/client/go/cmd/target.go b/client/go/cmd/target.go
index 7bb7a61a394..8b0cc4ee51a 100644
--- a/client/go/cmd/target.go
+++ b/client/go/cmd/target.go
@@ -12,11 +12,15 @@ import (
 )
 
 const (
-	targetFlag = "target"
-	cloudApi   = "https://api.vespa-external.aws.oath.cloud:4443"
+	applicationFlag = "application"
+	targetFlag      = "target"
+	cloudApi        = "https://api.vespa-external.aws.oath.cloud:4443"
 )
 
-var targetArg string
+var (
+	targetArg      string
+	applicationArg string
+)
 
 type target struct {
 	deploy   string
@@ -37,6 +41,11 @@ func addTargetFlag(command *cobra.Command) {
 	bindFlagToConfig(targetFlag, command)
 }
 
+func addApplicationFlag(command *cobra.Command) {
+	command.PersistentFlags().StringVarP(&applicationArg, applicationFlag, "a", "", "The application name to use for deployment")
+	bindFlagToConfig(applicationFlag, command)
+}
+
 func deployTarget() string {
 	return getTarget(deployContext).deploy
 }
@@ -49,11 +58,24 @@ func documentTarget() string {
 	return getTarget(documentContext).document
 }
 
-func getTarget(targetContext context) *target {
-	targetValue, err := getOption(targetFlag)
+func getApplication() string {
+	app, err := getOption(applicationFlag)
+	if err != nil {
+		log.Fatalf("a valid application must be specified")
+	}
+	return app
+}
+
+func getTargetType() string {
+	target, err := getOption(targetFlag)
 	if err != nil {
 		log.Fatalf("a valid target must be specified")
 	}
+	return target
+}
+
+func getTarget(targetContext context) *target {
+	targetValue := getTargetType()
 	if strings.HasPrefix(targetValue, "http") {
 		// TODO: Add default ports if missing
 		switch targetContext {
diff --git a/client/go/vespa/crypto_test.go b/client/go/vespa/crypto_test.go
index cb78f06fae9..693da04f70b 100644
--- a/client/go/vespa/crypto_test.go
+++ b/client/go/vespa/crypto_test.go
@@ -6,7 +6,6 @@ import (
 	"crypto/x509"
 	"encoding/base64"
 	"encoding/pem"
-	"fmt"
 	"io"
 	"math/rand"
 	"net/http"
@@ -49,7 +48,6 @@ func TestSignRequest(t *testing.T) {
 	key := req.Header.Get("X-Key")
 	assert.NotEmpty(t, key)
 	_, err = base64.StdEncoding.DecodeString(key)
-	fmt.Println(err)
 	assert.Nil(t, err)
 	auth := req.Header.Get("X-Authorization")
 	assert.NotEmpty(t, auth)