Improve dashboards test server to match to the real server (#3743)

## Why
Used in #3725 to provide local
test coverage.

## Tests
Existing tests pass with slight modifications.

Author: shreyas-goenka

acceptance/bundle/generate/dashboard-inplace/output.txt

@@ -12,9 +12,15 @@ Deployment complete!
 === update the dashboard
 >>> [CLI] lakeview update [DASHBOARD_ID] --serialized-dashboard {"a":"b"}
 {
-  "etag":"[UUID]",
+  "create_time":"[TIMESTAMP]",
+  "dashboard_id":"[DASHBOARD_ID]",
+  "display_name":"test dashboard",
+  "etag":"[NUMID]",
   "lifecycle_state":"ACTIVE",
-  "serialized_dashboard":"{\"a\":\"b\"}"
+  "parent_path":"/Users/[USERNAME]/.bundle/dashboard update inplace/default/resources",
+  "path":"/Users/[USERNAME]/.bundle/dashboard update inplace/default/resources/test dashboard.lvdash.json",
+  "serialized_dashboard":"{\"a\":\"b\"}",
+  "update_time":"[TIMESTAMP]Z"
 }
 
 === update the dashboard file using bundle generate

…bundle/generate/dashboard/dashboard.json …e/generate/dashboard/dashboard.json.tmplacceptance/bundle/generate/dashboard/dashboard.json renamed to acceptance/bundle/generate/dashboard/dashboard.json.tmpl acceptance/bundle/generate/dashboard/dashboard.json renamed to acceptance/bundle/generate/dashboard/dashboard.json.tmpl

@@ -1,5 +1,5 @@
 {
     "display_name": "test dashboard",
-    "parent_path": "/test",
+    "parent_path": "/Workspace/test-$UNIQUE_NAME",
     "serialized_dashboard": "{\"pages\":[{\"displayName\":\"New Page\",\"layout\":[],\"name\":\"12345678\"}]}"
 }

acceptance/bundle/generate/dashboard/output.txt

@@ -1,4 +1,6 @@
 
+>>> [CLI] workspace mkdirs /Workspace/test-[UNIQUE_NAME]
+
 >>> [CLI] bundle generate dashboard --existing-id [DASHBOARD_ID] --dashboard-dir out/dashboard --resource-dir out/resource
 Writing dashboard to "out/dashboard/test_dashboard.lvdash.json"
 Writing configuration to "out/resource/test_dashboard.dashboard.yml"

acceptance/bundle/generate/dashboard/script

@@ -1,4 +1,8 @@
+trace $CLI workspace mkdirs /Workspace/test-$UNIQUE_NAME
+
 # create a dashboard to import
+envsubst < dashboard.json.tmpl > dashboard.json
 dashboard_id=$($CLI lakeview create --json @dashboard.json | jq -r '.dashboard_id')
+rm dashboard.json
 
 trace $CLI bundle generate dashboard --existing-id $dashboard_id --dashboard-dir out/dashboard --resource-dir out/resource

acceptance/bundle/generate/dashboard/test.toml

@@ -5,3 +5,6 @@ New = '/'
 [[Repls]]
 Old = "[0-9a-f]{32}"
 New = "[DASHBOARD_ID]"
+
+[Env]
+MSYS_NO_PATHCONV = "1"

libs/testserver/dashboards.go

@@ -1,13 +1,30 @@
 package testserver
 
 import (
+	"crypto/rand"
+	"encoding/hex"
 	"encoding/json"
+	"fmt"
+	"path"
+	"path/filepath"
+	"strconv"
 	"strings"
+	"time"
 
 	"github.com/databricks/databricks-sdk-go/service/dashboards"
 	"github.com/databricks/databricks-sdk-go/service/workspace"
 )
 
+// Generate 32 character hex string for dashboard ID
+func generateDashboardId() (string, error) {
+	randomBytes := make([]byte, 16)
+	_, err := rand.Read(randomBytes)
+	if err != nil {
+		return "", err
+	}
+	return hex.EncodeToString(randomBytes), nil
+}
+
 func (s *FakeWorkspace) DashboardCreate(req Request) Response {
 	defer s.LockUnlock()()
 
@@ -18,17 +35,42 @@ func (s *FakeWorkspace) DashboardCreate(req Request) Response {
 		}
 	}
 
-	// Lakeview API strips hyphens from a uuid for dashboards
-	dashboard.DashboardId = strings.ReplaceAll(nextUUID(), "-", "")
+	if _, ok := s.directories[dashboard.ParentPath]; !ok {
+		return Response{
+			StatusCode: 404,
+			Body: map[string]string{
+				"message": fmt.Sprintf("Path (%s) doesn't exist.", dashboard.ParentPath),
+			},
+		}
+	}
+
+	var err error
+	dashboard.DashboardId, err = generateDashboardId()
+	if err != nil {
+		return Response{
+			StatusCode: 500,
+			Body: map[string]string{
+				"message": "Failed to generate dashboard ID",
+			},
+		}
+	}
 
 	// All dashboards are active by default:
 	dashboard.LifecycleState = dashboards.LifecycleStateActive
 
+	// Remove /Workspace prefix from parent_path. This matches the remote behavior.
+	if strings.HasPrefix(dashboard.ParentPath, "/Workspace/") {
+		dashboard.ParentPath = strings.TrimPrefix(dashboard.ParentPath, "/Workspace")
+	}
+
 	// Change path field if parent_path is provided
 	if dashboard.ParentPath != "" {
 		dashboard.Path = dashboard.ParentPath + "/" + dashboard.DisplayName + ".lvdash.json"
 	}
 
+	dashboard.CreateTime = strings.TrimSuffix(time.Now().UTC().Format(time.RFC3339), "Z")
+	dashboard.UpdateTime = dashboard.CreateTime
+
 	// Parse serializedDashboard into json and put it back as a string
 	if dashboard.SerializedDashboard != "" {
 		var dashboardContent map[string]any
@@ -42,46 +84,76 @@ func (s *FakeWorkspace) DashboardCreate(req Request) Response {
 				}
 			}
 			if updatedContent, err := json.Marshal(dashboardContent); err == nil {
-				dashboard.SerializedDashboard = string(updatedContent)
+				dashboard.SerializedDashboard = string(updatedContent) + "\n"
 			}
 		}
 	}
+	dashboard.Etag = "80611980"
 
 	s.Dashboards[dashboard.DashboardId] = dashboard
-	s.files[dashboard.Path] = FileEntry{
+	workspacePath := path.Join("/Workspace", dashboard.Path)
+	s.files[workspacePath] = FileEntry{
 		Info: workspace.ObjectInfo{
 			ObjectType: "DASHBOARD",
-			Path:       dashboard.Path,
-			ObjectId:   nextID(),
+			// Include the /Workspace prefix for workspace get-status API.
+			Path:       workspacePath,
+			ResourceId: dashboard.DashboardId,
 		},
 		Data: []byte(dashboard.SerializedDashboard),
 	}
 
 	return Response{
-		Body: dashboards.Dashboard{
-			DashboardId: dashboard.DashboardId,
-			Etag:        nextUUID(),
-		},
+		Body: dashboard,
 	}
 }
 
 func (s *FakeWorkspace) DashboardUpdate(req Request) Response {
 	defer s.LockUnlock()()
 
-	var dashboard dashboards.Dashboard
-	if err := json.Unmarshal(req.Body, &dashboard); err != nil {
+	var updateReq dashboards.Dashboard
+	if err := json.Unmarshal(req.Body, &updateReq); err != nil {
 		return Response{
 			StatusCode: 400,
 		}
 	}
 
-	// Update the etag for the dashboard.
-	dashboard.Etag = nextUUID()
+	dashboardId := req.Vars["dashboard_id"]
+	dashboard, ok := s.Dashboards[dashboardId]
+	if !ok {
+		return Response{
+			StatusCode: 404,
+		}
+	}
 
-	// All dashboards are active by default:
+	// Update etag.
+	prevEtag, err := strconv.Atoi(dashboard.Etag)
+	if err != nil {
+		return Response{
+			Body: map[string]string{
+				"message": "Invalid etag: " + dashboard.Etag,
+			},
+			StatusCode: 400,
+		}
+	}
+	nextEtag := prevEtag + 1
+	dashboard.Etag = strconv.Itoa(nextEtag)
+
+	// Update the dashboard.
 	dashboard.LifecycleState = dashboards.LifecycleStateActive
+	if updateReq.DisplayName != "" {
+		dashboard.DisplayName = updateReq.DisplayName
+		dir := filepath.Dir(dashboard.Path)
+		base := updateReq.DisplayName + ".lvdash.json"
+		dashboard.Path = filepath.Join(dir, base)
+	}
+	if updateReq.SerializedDashboard != "" {
+		dashboard.SerializedDashboard = updateReq.SerializedDashboard
+	}
+	if updateReq.WarehouseId != "" {
+		dashboard.WarehouseId = updateReq.WarehouseId
+	}
+	dashboard.UpdateTime = time.Now().UTC().Format(time.RFC3339)
 
-	dashboardId := req.Vars["dashboard_id"]
 	s.Dashboards[dashboardId] = dashboard
 
 	return Response{
@@ -92,16 +164,41 @@ func (s *FakeWorkspace) DashboardUpdate(req Request) Response {
 func (s *FakeWorkspace) DashboardPublish(req Request) Response {
 	defer s.LockUnlock()()
 
-	var dashboard dashboards.Dashboard
-	if err := json.Unmarshal(req.Body, &dashboard); err != nil {
+	var publishReq dashboards.PublishRequest
+	if err := json.Unmarshal(req.Body, &publishReq); err != nil {
 		return Response{
 			StatusCode: 400,
 		}
 	}
 
+	dashboardId := req.Vars["dashboard_id"]
+	dashboard, ok := s.Dashboards[dashboardId]
+	if !ok {
+		return Response{
+			StatusCode: 404,
+		}
+	}
+
+	publishedDashboard := dashboards.PublishedDashboard{
+		WarehouseId:      dashboard.WarehouseId,
+		DisplayName:      dashboard.DisplayName,
+		EmbedCredentials: publishReq.EmbedCredentials,
+	}
+
+	if publishReq.WarehouseId != "" {
+		publishedDashboard.WarehouseId = publishReq.WarehouseId
+	}
+	if publishReq.EmbedCredentials {
+		publishedDashboard.EmbedCredentials = publishReq.EmbedCredentials
+	}
+
+	s.PublishedDashboards[dashboardId] = publishedDashboard
+
 	return Response{
 		Body: dashboards.PublishedDashboard{
-			WarehouseId: dashboard.WarehouseId,
+			WarehouseId:      publishedDashboard.WarehouseId,
+			DisplayName:      publishedDashboard.DisplayName,
+			EmbedCredentials: publishedDashboard.EmbedCredentials,
 		},
 	}
 }

libs/testserver/fake_workspace.go

@@ -99,6 +99,7 @@ type FakeWorkspace struct {
 	SchemasGrants       map[string][]catalog.PrivilegeAssignment
 	Volumes             map[string]catalog.VolumeInfo
 	Dashboards          map[string]dashboards.Dashboard
+	PublishedDashboards map[string]dashboards.PublishedDashboard
 	SqlWarehouses       map[string]sql.GetWarehouseResponse
 	Alerts              map[string]sql.AlertV2
 	Experiments         map[string]ml.GetExperimentResponse
@@ -202,6 +203,7 @@ func NewFakeWorkspace(url, token string) *FakeWorkspace {
 		RegisteredModels:     map[string]catalog.RegisteredModelInfo{},
 		Volumes:              map[string]catalog.VolumeInfo{},
 		Dashboards:           map[string]dashboards.Dashboard{},
+		PublishedDashboards:  map[string]dashboards.PublishedDashboard{},
 		SqlWarehouses:        map[string]sql.GetWarehouseResponse{},
 		Repos:                map[string]workspace.RepoInfo{},
 		Acls:                 map[string][]workspace.AclItem{},

libs/testserver/handlers.go

@@ -238,6 +238,9 @@ func AddDefaultHandlers(server *Server) {
 	server.Handle("DELETE", "/api/2.0/lakeview/dashboards/{dashboard_id}", func(req Request) any {
 		return MapDelete(req.Workspace, req.Workspace.Dashboards, req.Vars["dashboard_id"])
 	})
+	server.Handle("GET", "/api/2.0/lakeview/dashboards/{dashboard_id}/published", func(req Request) any {
+		return MapGet(req.Workspace, req.Workspace.PublishedDashboards, req.Vars["dashboard_id"])
+	})
 
 	// Pipelines: