Refactor apps: Add legacy template support to databricks apps init

cmd/apps/import_resources_test.go

@@ -0,0 +1,217 @@
+package apps
+
+import (
+	"testing"
+
+	"github.com/databricks/databricks-sdk-go/service/apps"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestBuildResourcesMap(t *testing.T) {
+	t.Run("with SQL warehouse", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "sql-warehouse",
+					SqlWarehouse: &apps.AppResourceSqlWarehouse{
+						Id: "abc123",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Equal(t, "abc123", resources["sql-warehouse"])
+	})
+
+	t.Run("with serving endpoint", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "serving-endpoint",
+					ServingEndpoint: &apps.AppResourceServingEndpoint{
+						Name: "my-endpoint",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Equal(t, "my-endpoint", resources["serving-endpoint"])
+	})
+
+	t.Run("with experiment", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "experiment",
+					Experiment: &apps.AppResourceExperiment{
+						ExperimentId: "exp-456",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Equal(t, "exp-456", resources["experiment"])
+	})
+
+	t.Run("with database", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "database",
+					Database: &apps.AppResourceDatabase{
+						DatabaseName: "my-db",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Equal(t, "my-db", resources["database"])
+	})
+
+	t.Run("with Genie space", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "genie-space",
+					GenieSpace: &apps.AppResourceGenieSpace{
+						SpaceId: "space-123",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Equal(t, "space-123", resources["genie-space"])
+	})
+
+	t.Run("with job", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "job",
+					Job: &apps.AppResourceJob{
+						Id: "job-789",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Equal(t, "job-789", resources["job"])
+	})
+
+	t.Run("with UC securable", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "uc-securable",
+					UcSecurable: &apps.AppResourceUcSecurable{
+						SecurableFullName: "catalog.schema.table",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Equal(t, "catalog.schema.table", resources["uc-securable"])
+	})
+
+	t.Run("with multiple resources", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "sql-warehouse",
+					SqlWarehouse: &apps.AppResourceSqlWarehouse{
+						Id: "warehouse-1",
+					},
+				},
+				{
+					Name: "experiment",
+					Experiment: &apps.AppResourceExperiment{
+						ExperimentId: "exp-2",
+					},
+				},
+				{
+					Name: "serving-endpoint",
+					ServingEndpoint: &apps.AppResourceServingEndpoint{
+						Name: "endpoint-3",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Len(t, resources, 3)
+		assert.Equal(t, "warehouse-1", resources["sql-warehouse"])
+		assert.Equal(t, "exp-2", resources["experiment"])
+		assert.Equal(t, "endpoint-3", resources["serving-endpoint"])
+	})
+
+	t.Run("with empty resources", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Empty(t, resources)
+	})
+
+	t.Run("with nil resources", func(t *testing.T) {
+		app := &apps.App{
+			Resources: nil,
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Empty(t, resources)
+	})
+
+	t.Run("skips resources with empty name", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "",
+					SqlWarehouse: &apps.AppResourceSqlWarehouse{
+						Id: "warehouse-1",
+					},
+				},
+				{
+					Name: "experiment",
+					Experiment: &apps.AppResourceExperiment{
+						ExperimentId: "exp-2",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Len(t, resources, 1)
+		assert.NotContains(t, resources, "")
+		assert.Equal(t, "exp-2", resources["experiment"])
+	})
+
+	t.Run("skips resources with nil type", func(t *testing.T) {
+		app := &apps.App{
+			Resources: []apps.AppResource{
+				{
+					Name: "no-type-resource",
+					// All type fields are nil
+				},
+				{
+					Name: "experiment",
+					Experiment: &apps.AppResourceExperiment{
+						ExperimentId: "exp-2",
+					},
+				},
+			},
+		}
+
+		resources := buildResourcesMap(app)
+		assert.Len(t, resources, 1)
+		assert.NotContains(t, resources, "no-type-resource")
+		assert.Equal(t, "exp-2", resources["experiment"])
+	})
+}

cmd/apps/import_test.go

@@ -7,6 +7,7 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/databricks/cli/cmd/apps/internal"
 	"github.com/databricks/cli/libs/dyn"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
@@ -120,7 +121,7 @@ env: []`,
 
 			// Run function
 			appValue := tt.inputValue
-			filename, err := inlineAppConfigFile(&appValue)
+			filename, err := internal.InlineAppConfigFile(&appValue)
 
 			if tt.expectError {
 				assert.Error(t, err)
@@ -173,7 +174,7 @@ func TestInlineAppConfigFileErrors(t *testing.T) {
 		require.NoError(t, err)
 
 		appValue := dyn.V(map[string]dyn.Value{"name": dyn.V("test")})
-		_, err = inlineAppConfigFile(&appValue)
+		_, err = internal.InlineAppConfigFile(&appValue)
 		assert.Error(t, err)
 		assert.Contains(t, err.Error(), "failed to parse")
 	})
@@ -192,7 +193,7 @@ func TestInlineAppConfigFileErrors(t *testing.T) {
 		require.NoError(t, err)
 
 		appValue := dyn.V("not a map")
-		_, err = inlineAppConfigFile(&appValue)
+		_, err = internal.InlineAppConfigFile(&appValue)
 		assert.Error(t, err)
 		assert.Contains(t, err.Error(), "app value is not a map")
 	})
@@ -231,7 +232,7 @@ func TestInlineAppConfigFileErrors(t *testing.T) {
 		}
 
 		appValue := dyn.V(map[string]dyn.Value{"name": dyn.V("test")})
-		_, err = inlineAppConfigFile(&appValue)
+		_, err = internal.InlineAppConfigFile(&appValue)
 		assert.Error(t, err)
 		assert.Contains(t, err.Error(), "failed to read")
 	})
@@ -263,7 +264,7 @@ resources:
 			"description": dyn.V("existing description"),
 		})
 
-		filename, err := inlineAppConfigFile(&appValue)
+		filename, err := internal.InlineAppConfigFile(&appValue)
 		require.NoError(t, err)
 		assert.Equal(t, "app.yml", filename)
 
@@ -283,6 +284,76 @@ resources:
 	})
 }
 
+func TestInlineAppConfigFileCamelCaseConversion(t *testing.T) {
+	tmpDir := t.TempDir()
+	originalDir, err := os.Getwd()
+	require.NoError(t, err)
+	defer func() {
+		_ = os.Chdir(originalDir)
+	}()
+	err = os.Chdir(tmpDir)
+	require.NoError(t, err)
+
+	// Create app.yml with camelCase field names (as might come from API)
+	err = os.WriteFile("app.yml", []byte(`command: ["python", "app.py"]
+env:
+  - name: FOO
+    valueFrom: some-secret
+  - name: BAR
+    value: baz`), 0o644)
+	require.NoError(t, err)
+
+	appValue := dyn.V(map[string]dyn.Value{
+		"name": dyn.V("test-app"),
+	})
+
+	filename, err := internal.InlineAppConfigFile(&appValue)
+	require.NoError(t, err)
+	assert.Equal(t, "app.yml", filename)
+
+	// Verify that camelCase fields are converted to snake_case
+	appMap := appValue.MustMap()
+	var configValue dyn.Value
+	for _, pair := range appMap.Pairs() {
+		if pair.Key.MustString() == "config" {
+			configValue = pair.Value
+			break
+		}
+	}
+
+	require.NotEqual(t, dyn.KindInvalid, configValue.Kind(), "config section should exist")
+	configMap := configValue.MustMap()
+
+	var envValue dyn.Value
+	for _, pair := range configMap.Pairs() {
+		if pair.Key.MustString() == "env" {
+			envValue = pair.Value
+			break
+		}
+	}
+
+	require.NotEqual(t, dyn.KindInvalid, envValue.Kind(), "env should exist in config")
+	envList := envValue.MustSequence()
+	require.Len(t, envList, 2, "should have 2 env vars")
+
+	// Check first env var has value_from (snake_case), not valueFrom (camelCase)
+	firstEnv := envList[0].MustMap()
+	var hasValueFrom bool
+	var hasValueFromCamel bool
+	for _, pair := range firstEnv.Pairs() {
+		key := pair.Key.MustString()
+		if key == "value_from" {
+			hasValueFrom = true
+		}
+		if key == "valueFrom" {
+			hasValueFromCamel = true
+		}
+	}
+
+	assert.True(t, hasValueFrom, "should have value_from (snake_case) field")
+	assert.False(t, hasValueFromCamel, "should NOT have valueFrom (camelCase) field")
+}
+
 func TestPathContainsBundleFolder(t *testing.T) {
 	tests := []struct {
 		name     string