Fix lakeview publish to default embed_credentials to false

Author: Varun Deep Saini

acceptance/workspace/lakeview/publish/test.toml

@@ -1,5 +1,8 @@
 RecordRequests = true
 
+[Env]
+MSYS_NO_PATHCONV = "1"
+
 [[Repls]]
 Old = "[a-f0-9]{32}"
 New = "[DASHBOARD_ID]"

bundle/direct/graph_test.go

@@ -0,0 +1,238 @@
+package direct
+
+import (
+	"sort"
+	"sync"
+	"testing"
+
+	"github.com/databricks/cli/bundle/deployplan"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+func TestMakeGraph_DeploymentOrder(t *testing.T) {
+	// Test that deployment uses normal dependency order: dependency before dependent
+	// If B depends on A, A should be deployed before B
+	plan := deployplan.NewPlan()
+	plan.Plan["resources.jobs.a"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeCreate.String(),
+	}
+	plan.Plan["resources.jobs.b"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeCreate.String(),
+		DependsOn: []deployplan.DependsOnEntry{
+			{Node: "resources.jobs.a", Label: "${resources.jobs.a.id}"},
+		},
+	}
+
+	g, err := makeGraph(plan)
+	require.NoError(t, err)
+
+	// Track execution order
+	var mu sync.Mutex
+	var order []string
+
+	g.Run(1, func(node string, failedDep *string) bool {
+		mu.Lock()
+		order = append(order, node)
+		mu.Unlock()
+		return true
+	})
+
+	// A should be deployed before B
+	require.Equal(t, []string{"resources.jobs.a", "resources.jobs.b"}, order)
+}
+
+func TestMakeGraph_DeletionOrder(t *testing.T) {
+	// Test that deletion uses reverse dependency order: dependent before dependency
+	// If B depends on A, B should be deleted before A
+	plan := deployplan.NewPlan()
+	plan.Plan["resources.jobs.a"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+	}
+	plan.Plan["resources.jobs.b"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+		DependsOn: []deployplan.DependsOnEntry{
+			{Node: "resources.jobs.a", Label: "${resources.jobs.a.id}"},
+		},
+	}
+
+	g, err := makeGraph(plan)
+	require.NoError(t, err)
+
+	// Track execution order
+	var mu sync.Mutex
+	var order []string
+
+	g.Run(1, func(node string, failedDep *string) bool {
+		mu.Lock()
+		order = append(order, node)
+		mu.Unlock()
+		return true
+	})
+
+	// B should be deleted before A (reverse of deployment order)
+	require.Equal(t, []string{"resources.jobs.b", "resources.jobs.a"}, order)
+}
+
+func TestMakeGraph_DeletionOrderChain(t *testing.T) {
+	// Test chain of dependencies: C depends on B, B depends on A
+	// Deletion order should be: C, B, A
+	plan := deployplan.NewPlan()
+	plan.Plan["resources.jobs.a"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+	}
+	plan.Plan["resources.jobs.b"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+		DependsOn: []deployplan.DependsOnEntry{
+			{Node: "resources.jobs.a", Label: "${resources.jobs.a.id}"},
+		},
+	}
+	plan.Plan["resources.jobs.c"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+		DependsOn: []deployplan.DependsOnEntry{
+			{Node: "resources.jobs.b", Label: "${resources.jobs.b.id}"},
+		},
+	}
+
+	g, err := makeGraph(plan)
+	require.NoError(t, err)
+
+	var mu sync.Mutex
+	var order []string
+
+	g.Run(1, func(node string, failedDep *string) bool {
+		mu.Lock()
+		order = append(order, node)
+		mu.Unlock()
+		return true
+	})
+
+	// C should be deleted first, then B, then A
+	require.Equal(t, []string{"resources.jobs.c", "resources.jobs.b", "resources.jobs.a"}, order)
+}
+
+func TestMakeGraph_MixedDeployAndDelete(t *testing.T) {
+	// Test mixed scenario: some resources being created, some deleted
+	plan := deployplan.NewPlan()
+	// A is being created
+	plan.Plan["resources.jobs.a"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeCreate.String(),
+	}
+	// B is being created and depends on A
+	plan.Plan["resources.jobs.b"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeCreate.String(),
+		DependsOn: []deployplan.DependsOnEntry{
+			{Node: "resources.jobs.a", Label: "${resources.jobs.a.id}"},
+		},
+	}
+	// C is being deleted (independent)
+	plan.Plan["resources.jobs.c"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+	}
+	// D is being deleted (independent)
+	plan.Plan["resources.jobs.d"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+	}
+
+	g, err := makeGraph(plan)
+	require.NoError(t, err)
+
+	var mu sync.Mutex
+	var order []string
+
+	g.Run(1, func(node string, failedDep *string) bool {
+		mu.Lock()
+		order = append(order, node)
+		mu.Unlock()
+		return true
+	})
+
+	// Verify A is before B (deployment order)
+	aIdx := indexOf(order, "resources.jobs.a")
+	bIdx := indexOf(order, "resources.jobs.b")
+	assert.Less(t, aIdx, bIdx, "A should be deployed before B")
+
+	// C and D can be in any order (independent deletes)
+	assert.Contains(t, order, "resources.jobs.c")
+	assert.Contains(t, order, "resources.jobs.d")
+}
+
+func TestMakeGraph_DeleteWithMissingDependency(t *testing.T) {
+	// Test that delete actions don't fail if a dependency doesn't exist in the plan
+	// (e.g., the dependency resource was not removed from config)
+	plan := deployplan.NewPlan()
+	plan.Plan["resources.jobs.b"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+		DependsOn: []deployplan.DependsOnEntry{
+			{Node: "resources.jobs.a", Label: "${resources.jobs.a.id}"},
+		},
+	}
+
+	g, err := makeGraph(plan)
+	require.NoError(t, err)
+
+	var executed []string
+	g.Run(1, func(node string, failedDep *string) bool {
+		executed = append(executed, node)
+		return true
+	})
+
+	require.Equal(t, []string{"resources.jobs.b"}, executed)
+}
+
+func TestMakeGraph_CreateWithMissingDependency(t *testing.T) {
+	// Test that create actions fail if a dependency doesn't exist in the plan
+	plan := deployplan.NewPlan()
+	plan.Plan["resources.jobs.b"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeCreate.String(),
+		DependsOn: []deployplan.DependsOnEntry{
+			{Node: "resources.jobs.a", Label: "${resources.jobs.a.id}"},
+		},
+	}
+
+	_, err := makeGraph(plan)
+	require.Error(t, err)
+	assert.Contains(t, err.Error(), "invalid dependency")
+}
+
+func TestMakeGraph_ParallelDeletions(t *testing.T) {
+	// Test that independent deletions can run in parallel
+	plan := deployplan.NewPlan()
+	// A, B, C are independent deletions
+	plan.Plan["resources.jobs.a"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+	}
+	plan.Plan["resources.jobs.b"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+	}
+	plan.Plan["resources.jobs.c"] = &deployplan.PlanEntry{
+		Action: deployplan.ActionTypeDelete.String(),
+	}
+
+	g, err := makeGraph(plan)
+	require.NoError(t, err)
+
+	var mu sync.Mutex
+	var executed []string
+
+	// Use parallelism > 1 to allow parallel execution
+	g.Run(3, func(node string, failedDep *string) bool {
+		mu.Lock()
+		executed = append(executed, node)
+		mu.Unlock()
+		return true
+	})
+
+	// All three should be executed (order doesn't matter for independent resources)
+	sort.Strings(executed)
+	require.Equal(t, []string{"resources.jobs.a", "resources.jobs.b", "resources.jobs.c"}, executed)
+}
+
+func indexOf(slice []string, item string) int {
+	for i, v := range slice {
+		if v == item {
+			return i
+		}
+	}
+	return -1
+}