direct/testserver: improve app test realism

Make testserver app DELETE asynchronous (sets DELETING state) to match
real API behaviour. AppsGet auto-removes the app after returning it in
DELETING state, so the next request sees it as gone.

app_test.go: use real SDK calls (Create + DeleteByName) to put the app
in DELETING state before testing DoCreate retry logic, instead of
injecting state directly. RetriesWhenGetReturnsNotFound uses a one-shot
POST override so GET returns 404 naturally without a custom GET handler.

all_test.go: retry DoRead once after DoDelete to let async deletions
(DELETING → gone) clear before asserting the resource is absent.

Add Server.GetWorkspace to testserver for pre-seeding state in tests.

Co-authored-by: Denis Bilenko

Author: denik

bundle/direct/dresources/all_test.go

@@ -904,6 +904,11 @@ func testCRUD(t *testing.T, group string, adapter *Adapter, client *databricks.W
 	deleteIsNoop := strings.HasSuffix(group, "permissions") || strings.HasSuffix(group, "grants")
 
 	remoteAfterDelete, err := adapter.DoRead(ctx, createdID)
+	// Some resources delete asynchronously (e.g. apps transition through a
+	// DELETING state). Read once more to let that pending state clear.
+	if err == nil && remoteAfterDelete != nil && !deleteIsNoop {
+		remoteAfterDelete, err = adapter.DoRead(ctx, createdID)
+	}
 	if deleteIsNoop {
 		require.NoError(t, err)
 	} else {

bundle/direct/dresources/app_test.go

@@ -17,47 +17,6 @@ import (
 // an app already exists but is in DELETING state.
 func TestAppDoCreate_RetriesWhenAppIsDeleting(t *testing.T) {
 	server := testserver.New(t)
-
-	createCallCount := 0
-	getCallCount := 0
-
-	server.Handle("POST", "/api/2.0/apps", func(req testserver.Request) any {
-		createCallCount++
-		if createCallCount == 1 {
-			return testserver.Response{
-				StatusCode: 409,
-				Body: map[string]string{
-					"error_code": "RESOURCE_ALREADY_EXISTS",
-					"message":    "An app with the same name already exists.",
-				},
-			}
-		}
-		return apps.App{
-			Name: "test-app",
-			ComputeStatus: &apps.ComputeStatus{
-				State: apps.ComputeStateActive,
-			},
-		}
-	})
-
-	server.Handle("GET", "/api/2.0/apps/{name}", func(req testserver.Request) any {
-		getCallCount++
-		if getCallCount == 1 {
-			return apps.App{
-				Name: req.Vars["name"],
-				ComputeStatus: &apps.ComputeStatus{
-					State: apps.ComputeStateDeleting,
-				},
-			}
-		}
-		return apps.App{
-			Name: req.Vars["name"],
-			ComputeStatus: &apps.ComputeStatus{
-				State: apps.ComputeStateActive,
-			},
-		}
-	})
-
 	testserver.AddDefaultHandlers(server)
 
 	client, err := databricks.NewWorkspaceClient(&databricks.Config{
@@ -66,60 +25,42 @@ func TestAppDoCreate_RetriesWhenAppIsDeleting(t *testing.T) {
 	})
 	require.NoError(t, err)
 
-	r := (&ResourceApp{}).New(client)
 	ctx := t.Context()
+
+	// Create then delete an app to put it in DELETING state.
+	// The testserver's DELETE is asynchronous: it sets DELETING rather than
+	// removing immediately, so the retry create will find the app in that state.
+	_, err = client.Apps.Create(ctx, apps.CreateAppRequest{App: apps.App{Name: "test-app"}})
+	require.NoError(t, err)
+	_, err = client.Apps.DeleteByName(ctx, "test-app")
+	require.NoError(t, err)
+
+	r := (&ResourceApp{}).New(client)
 	name, _, err := r.DoCreate(ctx, NewNopEngine(reflect.TypeFor[*AppState]()), &AppState{App: apps.App{Name: "test-app"}})
 
 	require.NoError(t, err)
 	assert.Equal(t, "test-app", name)
-	assert.Equal(t, 2, createCallCount, "expected Create to be called twice (1 retry)")
-	assert.Equal(t, 2, getCallCount, "expected Get to be called twice: once to check app state, once by waitForApp")
 }
 
 // TestAppDoCreate_RetriesWhenGetReturnsNotFound verifies that DoCreate retries
 // when the app was just deleted between the create call and the get call.
 func TestAppDoCreate_RetriesWhenGetReturnsNotFound(t *testing.T) {
 	server := testserver.New(t)
 
-	createCallCount := 0
-	getCallCount := 0
-
+	// Simulate a race: the app existed when Create was called (returns 409) but
+	// was deleted before the existence check (GET returns 404). The first POST
+	// returns 409 without storing anything so the standard GET handler returns
+	// 404 naturally, and the retry POST creates the app normally.
+	rejectedOnce := false
 	server.Handle("POST", "/api/2.0/apps", func(req testserver.Request) any {
-		createCallCount++
-		if createCallCount == 1 {
+		if !rejectedOnce {
+			rejectedOnce = true
 			return testserver.Response{
 				StatusCode: 409,
-				Body: map[string]string{
-					"error_code": "RESOURCE_ALREADY_EXISTS",
-					"message":    "An app with the same name already exists.",
-				},
+				Body:       map[string]string{"error_code": "RESOURCE_ALREADY_EXISTS", "message": "An app with the same name already exists."},
 			}
 		}
-		return apps.App{
-			Name: "test-app",
-			ComputeStatus: &apps.ComputeStatus{
-				State: apps.ComputeStateActive,
-			},
-		}
-	})
-
-	server.Handle("GET", "/api/2.0/apps/{name}", func(req testserver.Request) any {
-		getCallCount++
-		if getCallCount == 1 {
-			return testserver.Response{
-				StatusCode: 404,
-				Body: map[string]string{
-					"error_code": "RESOURCE_DOES_NOT_EXIST",
-					"message":    "App not found.",
-				},
-			}
-		}
-		return apps.App{
-			Name: req.Vars["name"],
-			ComputeStatus: &apps.ComputeStatus{
-				State: apps.ComputeStateActive,
-			},
-		}
+		return req.Workspace.AppsUpsert(req, "")
 	})
 
 	testserver.AddDefaultHandlers(server)
@@ -136,8 +77,6 @@ func TestAppDoCreate_RetriesWhenGetReturnsNotFound(t *testing.T) {
 
 	require.NoError(t, err)
 	assert.Equal(t, "test-app", name)
-	assert.Equal(t, 2, createCallCount, "expected Create to be called twice")
-	assert.Equal(t, 2, getCallCount, "expected Get to be called twice: once to check app state, once by waitForApp")
 }
 
 func TestAppDoUpdate_UpdateMaskHasAllFields(t *testing.T) {

libs/testserver/apps.go

@@ -72,6 +72,42 @@ func (s *FakeWorkspace) AppsCreateUpdate(req Request, name string) Response {
 	}
 }
 
+func (s *FakeWorkspace) AppsGet(_ Request, name string) Response {
+	defer s.LockUnlock()()
+
+	app, ok := s.Apps[name]
+	if !ok {
+		return Response{StatusCode: 404, Body: map[string]string{"message": "App not found: " + name}}
+	}
+
+	// When an app is in DELETING state, remove it from the store after returning.
+	// This simulates deletion completing so the next create attempt succeeds.
+	if app.ComputeStatus != nil && app.ComputeStatus.State == apps.ComputeStateDeleting {
+		delete(s.Apps, name)
+	}
+
+	return Response{Body: app}
+}
+
+// AppsDelete marks an app as DELETING, simulating asynchronous deletion.
+// The app is removed from the store when it is next retrieved via AppsGet.
+func (s *FakeWorkspace) AppsDelete(_ Request, name string) Response {
+	defer s.LockUnlock()()
+
+	app, ok := s.Apps[name]
+	if !ok {
+		return Response{StatusCode: 404}
+	}
+
+	app.ComputeStatus = &apps.ComputeStatus{
+		State:   apps.ComputeStateDeleting,
+		Message: "App compute is being deleted.",
+	}
+	s.Apps[name] = app
+
+	return Response{}
+}
+
 func (s *FakeWorkspace) AppsGetUpdate(_ Request, name string) Response {
 	defer s.LockUnlock()()
 

libs/testserver/handlers.go

@@ -404,7 +404,7 @@ func AddDefaultHandlers(server *Server) {
 	})
 
 	server.Handle("GET", "/api/2.0/apps/{name}", func(req Request) any {
-		return MapGet(req.Workspace, req.Workspace.Apps, req.Vars["name"])
+		return req.Workspace.AppsGet(req, req.Vars["name"])
 	})
 
 	server.Handle("POST", "/api/2.0/apps", func(req Request) any {
@@ -416,7 +416,7 @@ func AddDefaultHandlers(server *Server) {
 	})
 
 	server.Handle("DELETE", "/api/2.0/apps/{name}", func(req Request) any {
-		return MapDelete(req.Workspace, req.Workspace.Apps, req.Vars["name"])
+		return req.Workspace.AppsDelete(req, req.Vars["name"])
 	})
 
 	// Schemas:

libs/testserver/server.go

@@ -296,6 +296,12 @@ Response.Body = '<response body here>'
 	return s
 }
 
+// GetWorkspace returns (creating if necessary) the FakeWorkspace for the given token.
+// Use this in tests to pre-seed state before making requests.
+func (s *Server) GetWorkspace(token string) *FakeWorkspace {
+	return s.getWorkspaceForToken(token)
+}
+
 func (s *Server) getWorkspaceForToken(token string) *FakeWorkspace {
 	if token == "" {
 		return nil