+10% coverage

Author: nfx

cmd/labs/project/installer.go

@@ -10,13 +10,13 @@ import (
 
 	"github.com/databricks/cli/cmd/labs/github"
 	"github.com/databricks/cli/cmd/labs/unpack"
+	"github.com/databricks/cli/cmd/root"
 	"github.com/databricks/cli/cmd/workspace/clusters"
 	"github.com/databricks/cli/libs/cmdio"
 	"github.com/databricks/cli/libs/log"
 	"github.com/databricks/cli/libs/process"
 	"github.com/databricks/cli/libs/python"
 	"github.com/databricks/databricks-sdk-go"
-	"github.com/databricks/databricks-sdk-go/config"
 	"github.com/databricks/databricks-sdk-go/service/compute"
 	"github.com/databricks/databricks-sdk-go/service/sql"
 	"github.com/fatih/color"
@@ -76,7 +76,13 @@ func (i *installer) Install(ctx context.Context) error {
 	}
 	i.folder = PathInLabs(ctx, i.Name)
 	w, err := i.login(ctx)
-	if err != nil {
+	if err != nil && errors.Is(err, root.ErrNoConfiguration) {
+		cfg := i.Installer.envAwareConfig(ctx)
+		w, err = databricks.NewWorkspaceClient((*databricks.Config)(cfg))
+		if err != nil {
+			return fmt.Errorf("no ~/.databrickscfg: %w", err)
+		}
+	} else if err != nil {
 		return fmt.Errorf("login: %w", err)
 	}
 	err = i.downloadLibrary(ctx)
@@ -141,7 +147,7 @@ func (i *installer) login(ctx context.Context) (*databricks.WorkspaceClient, err
 	}
 	cfg, err := i.metaEntrypoint(ctx).validLogin(i.cmd)
 	if errors.Is(err, ErrNoLoginConfig) {
-		cfg = &config.Config{}
+		cfg = i.Installer.envAwareConfig(ctx)
 	} else if err != nil {
 		return nil, fmt.Errorf("valid: %w", err)
 	}

cmd/labs/project/installer_test.go

@@ -24,6 +24,7 @@ import (
 	"github.com/databricks/cli/libs/python"
 	"github.com/databricks/databricks-sdk-go/service/compute"
 	"github.com/databricks/databricks-sdk-go/service/iam"
+	"github.com/databricks/databricks-sdk-go/service/sql"
 	"github.com/stretchr/testify/require"
 )
 
@@ -191,7 +192,6 @@ func TestInstallerWorksForReleases(t *testing.T) {
 }
 
 func TestInstallerWorksForDevelopment(t *testing.T) {
-	t.SkipNow()
 	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		if r.URL.Path == "/api/2.0/clusters/list" {
 			respondWithJSON(t, w, compute.ListClustersResponse{
@@ -200,7 +200,7 @@ func TestInstallerWorksForDevelopment(t *testing.T) {
 						ClusterId:        "abc-id",
 						ClusterName:      "first shared",
 						DataSecurityMode: compute.DataSecurityModeUserIsolation,
-						SparkVersion:     "14.5.x-whatever",
+						SparkVersion:     "12.2.x-whatever",
 						State:            compute.StateRunning,
 					},
 					{
@@ -238,6 +238,18 @@ func TestInstallerWorksForDevelopment(t *testing.T) {
 			})
 			return
 		}
+		if r.URL.Path == "/api/2.0/sql/warehouses" {
+			respondWithJSON(t, w, sql.ListWarehousesResponse{
+				Warehouses: []sql.EndpointInfo{
+					{
+						Id:            "efg-id",
+						Name:          "First PRO Warehouse",
+						WarehouseType: sql.EndpointInfoWarehouseTypePro,
+					},
+				},
+			})
+			return
+		}
 		t.Logf("Requested: %s", r.URL.Path)
 		t.FailNow()
 	}))
@@ -288,9 +300,5 @@ account_id = abc
 	defer r.CloseStdin()
 
 	r.RunBackground()
-	r.WaitForTextPrinted("Workspace profiles defined", 5*time.Second)
-	r.SendText("profile-one\n")
-	r.WaitForTextPrinted("Choose compatible cluster", 5*time.Second)
-	r.SendText("\n\n")
 	r.WaitForTextPrinted("setting up important infrastructure", 5*time.Second)
 }

cmd/labs/project/login.go

@@ -70,7 +70,11 @@ func (lc *loginConfig) askCluster(ctx context.Context, w *databricks.WorkspaceCl
 	if !cmdio.IsInteractive(ctx) {
 		return ErrNotInTTY
 	}
-	lc.ClusterID, err = clusters.AskForCompatibleCluster(ctx, w, lc.Installer.MinRuntimeVersion)
+	clusterID, err := clusters.AskForCompatibleCluster(ctx, w, lc.Installer.MinRuntimeVersion)
+	if err != nil {
+		return fmt.Errorf("select: %w", err)
+	}
+	lc.ClusterID = clusterID
 	return
 }
 

cmd/root/auth.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"errors"
 	"fmt"
+	"io/fs"
 	"net/http"
 	"os"
 
@@ -173,9 +174,13 @@ func SetWorkspaceClient(ctx context.Context, w *databricks.WorkspaceClient) cont
 	return context.WithValue(ctx, &workspaceClient, w)
 }
 
+var ErrNoConfiguration = errors.New("no configuration file found")
+
 func transformLoadError(path string, err error) error {
-	if os.IsNotExist(err) {
-		return fmt.Errorf("no configuration file found at %s; please create one first", path)
+	if os.IsNotExist(err) || errors.Is(err, fs.ErrNotExist) {
+		// downstreams need to handle these errors properly, but we erase the fs.ErrNotExist
+		// TODO: expose this as error through SDK
+		return fmt.Errorf("%w at %s; please create one first", ErrNoConfiguration, path)
 	}
 	return err
 }

cmd/workspace/clusters/uc.go

@@ -54,6 +54,39 @@ func IsUnityCatalogCompatible(cluster *compute.ClusterDetails, minVersion string
 
 var ErrNoCompatibleClusters = errors.New("no compatible clusters found")
 
+type compatibleCluster struct {
+	compute.ClusterDetails
+	versionName string
+}
+
+func (v compatibleCluster) Access() string {
+	switch v.DataSecurityMode {
+	case compute.DataSecurityModeUserIsolation:
+		return "Shared"
+	case compute.DataSecurityModeSingleUser:
+		return "Assigned"
+	default:
+		return "Unknown"
+	}
+}
+
+func (v compatibleCluster) Runtime() string {
+	runtime, _, _ := strings.Cut(v.versionName, " (")
+	return runtime
+}
+
+func (v compatibleCluster) State() string {
+	state := v.ClusterDetails.State
+	switch state {
+	case compute.StateRunning, compute.StateResizing:
+		return color.GreenString(state.String())
+	case compute.StateError, compute.StateTerminated, compute.StateTerminating, compute.StateUnknown:
+		return color.RedString(state.String())
+	default:
+		return color.BlueString(state.String())
+	}
+}
+
 func AskForCompatibleCluster(ctx context.Context, w *databricks.WorkspaceClient, minVersion string) (string, error) {
 	all, err := w.Clusters.ListAll(ctx, compute.ListClustersRequest{
 		CanUseClient: "NOTEBOOKS",
@@ -73,13 +106,6 @@ func AskForCompatibleCluster(ctx context.Context, w *databricks.WorkspaceClient,
 	for _, v := range sv.Versions {
 		versions[v.Key] = v.Name
 	}
-	type compatibleCluster struct {
-		Id      string
-		Name    string
-		Access  string
-		State   string
-		Runtime string
-	}
 	var compatible []compatibleCluster
 	for _, v := range all {
 		if !IsUnityCatalogCompatible(&v, minVersion) {
@@ -88,48 +114,34 @@ func AskForCompatibleCluster(ctx context.Context, w *databricks.WorkspaceClient,
 		if v.SingleUserName != "" && v.SingleUserName != me.UserName {
 			continue
 		}
-		var cluster compatibleCluster
-		switch v.DataSecurityMode {
-		case compute.DataSecurityModeUserIsolation:
-			cluster.Access = "Shared"
-		case compute.DataSecurityModeSingleUser:
-			cluster.Access = "Assigned"
-		}
-		switch v.State {
-		case compute.StateRunning, compute.StateResizing:
-			cluster.State = color.GreenString(v.State.String())
-		case compute.StateError, compute.StateTerminated, compute.StateTerminating, compute.StateUnknown:
-			cluster.State = color.RedString(v.State.String())
-		default:
-			cluster.State = color.BlueString(v.State.String())
-		}
-		runtime, _, _ := strings.Cut(versions[v.SparkVersion], " (")
-		cluster.Runtime = runtime
-		compatible = append(compatible, cluster)
+		compatible = append(compatible, compatibleCluster{
+			ClusterDetails: v,
+			versionName:    versions[v.SparkVersion],
+		})
 	}
 	if len(compatible) == 0 {
 		return "", ErrNoCompatibleClusters
 	}
 	if len(compatible) == 1 {
-		return compatible[0].Id, nil
+		return compatible[0].ClusterId, nil
 	}
 	i, _, err := cmdio.RunSelect(ctx, &promptui.Select{
 		Label: "Choose compatible cluster",
 		Items: compatible,
 		Searcher: func(input string, idx int) bool {
-			lower := strings.ToLower(compatible[idx].Name)
+			lower := strings.ToLower(compatible[idx].ClusterName)
 			return strings.Contains(lower, input)
 		},
 		StartInSearchMode: true,
 		Templates: &promptui.SelectTemplates{
-			Label:    "{{ . | faint }}",
-			Active:   `{{.Name | bold}} ({{.State}} {{.Access}} Runtime {{.Runtime}})`,
-			Inactive: `{{.Name}}`,
-			Selected: `{{ "Configured cluster" | faint }}: {{ .Name | bold }} ({{.Id | faint}})`,
+			Label:    "{{.ClusterName | faint}}",
+			Active:   `{{.ClusterName | bold}} ({{.State}} {{.Access}} Runtime {{.Runtime}})`,
+			Inactive: `{{.ClusterName}} ({{.State}} {{.Access}} Runtime {{.Runtime}})`,
+			Selected: `{{ "Configured cluster" | faint }}: {{ .ClusterName | bold }} ({{.ClusterId | faint}})`,
 		},
 	})
 	if err != nil {
 		return "", err
 	}
-	return compatible[i].Id, nil
+	return compatible[i].ClusterId, nil
 }

cmd/workspace/warehouses/ask.go

@@ -22,6 +22,7 @@ func AskForCompatibleWarehouses(ctx context.Context, w *databricks.WorkspaceClie
 	for _, v := range types {
 		allowed[v] = true
 	}
+	var lastWarehouseID string
 	names := map[string]string{}
 	for _, v := range all {
 		if !allowed[v.WarehouseType] {
@@ -38,9 +39,13 @@ func AskForCompatibleWarehouses(ctx context.Context, w *databricks.WorkspaceClie
 		}
 		visibleTouser := fmt.Sprintf("%s (%s %s)", v.Name, state, v.WarehouseType)
 		names[visibleTouser] = v.Id
+		lastWarehouseID = v.Id
 	}
 	if len(names) == 0 {
 		return "", ErrNoCompatibleWarehouses
 	}
+	if len(names) == 1 {
+		return lastWarehouseID, nil
+	}
 	return cmdio.Select(ctx, names, "Choose SQL Warehouse")
 }