added method spies to improve grpc server mocking (#6)

Author: Davidonium

internal/testutil/fake_backup.go

@@ -22,92 +22,115 @@ type FakeBackupService struct {
 	CreateBackupScheduleFunc func(context.Context, *backupv1.CreateBackupScheduleRequest) (*backupv1.CreateBackupScheduleResponse, error)
 	UpdateBackupScheduleFunc func(context.Context, *backupv1.UpdateBackupScheduleRequest) (*backupv1.UpdateBackupScheduleResponse, error)
 	DeleteBackupScheduleFunc func(context.Context, *backupv1.DeleteBackupScheduleRequest) (*backupv1.DeleteBackupScheduleResponse, error)
+
+	ListBackupsCalls          MethodSpy[*backupv1.ListBackupsRequest, *backupv1.ListBackupsResponse]
+	GetBackupCalls            MethodSpy[*backupv1.GetBackupRequest, *backupv1.GetBackupResponse]
+	CreateBackupCalls         MethodSpy[*backupv1.CreateBackupRequest, *backupv1.CreateBackupResponse]
+	DeleteBackupCalls         MethodSpy[*backupv1.DeleteBackupRequest, *backupv1.DeleteBackupResponse]
+	ListBackupRestoresCalls   MethodSpy[*backupv1.ListBackupRestoresRequest, *backupv1.ListBackupRestoresResponse]
+	RestoreBackupCalls        MethodSpy[*backupv1.RestoreBackupRequest, *backupv1.RestoreBackupResponse]
+	ListBackupSchedulesCalls  MethodSpy[*backupv1.ListBackupSchedulesRequest, *backupv1.ListBackupSchedulesResponse]
+	GetBackupScheduleCalls    MethodSpy[*backupv1.GetBackupScheduleRequest, *backupv1.GetBackupScheduleResponse]
+	CreateBackupScheduleCalls MethodSpy[*backupv1.CreateBackupScheduleRequest, *backupv1.CreateBackupScheduleResponse]
+	UpdateBackupScheduleCalls MethodSpy[*backupv1.UpdateBackupScheduleRequest, *backupv1.UpdateBackupScheduleResponse]
+	DeleteBackupScheduleCalls MethodSpy[*backupv1.DeleteBackupScheduleRequest, *backupv1.DeleteBackupScheduleResponse]
 }
 
-// ListBackups delegates to ListBackupsFunc if set.
+// ListBackups delegates to ListBackupsFunc if set, otherwise dispatches via ListBackupsCalls.
 func (f *FakeBackupService) ListBackups(ctx context.Context, req *backupv1.ListBackupsRequest) (*backupv1.ListBackupsResponse, error) {
+	f.ListBackupsCalls.record(req)
 	if f.ListBackupsFunc != nil {
 		return f.ListBackupsFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.ListBackups(ctx, req)
+	return f.ListBackupsCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.ListBackups)
 }
 
-// GetBackup delegates to GetBackupFunc if set.
+// GetBackup delegates to GetBackupFunc if set, otherwise dispatches via GetBackupCalls.
 func (f *FakeBackupService) GetBackup(ctx context.Context, req *backupv1.GetBackupRequest) (*backupv1.GetBackupResponse, error) {
+	f.GetBackupCalls.record(req)
 	if f.GetBackupFunc != nil {
 		return f.GetBackupFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.GetBackup(ctx, req)
+	return f.GetBackupCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.GetBackup)
 }
 
-// CreateBackup delegates to CreateBackupFunc if set.
+// CreateBackup delegates to CreateBackupFunc if set, otherwise dispatches via CreateBackupCalls.
 func (f *FakeBackupService) CreateBackup(ctx context.Context, req *backupv1.CreateBackupRequest) (*backupv1.CreateBackupResponse, error) {
+	f.CreateBackupCalls.record(req)
 	if f.CreateBackupFunc != nil {
 		return f.CreateBackupFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.CreateBackup(ctx, req)
+	return f.CreateBackupCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.CreateBackup)
 }
 
-// DeleteBackup delegates to DeleteBackupFunc if set.
+// DeleteBackup delegates to DeleteBackupFunc if set, otherwise dispatches via DeleteBackupCalls.
 func (f *FakeBackupService) DeleteBackup(ctx context.Context, req *backupv1.DeleteBackupRequest) (*backupv1.DeleteBackupResponse, error) {
+	f.DeleteBackupCalls.record(req)
 	if f.DeleteBackupFunc != nil {
 		return f.DeleteBackupFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.DeleteBackup(ctx, req)
+	return f.DeleteBackupCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.DeleteBackup)
 }
 
-// ListBackupRestores delegates to ListBackupRestoresFunc if set.
+// ListBackupRestores delegates to ListBackupRestoresFunc if set, otherwise dispatches via ListBackupRestoresCalls.
 func (f *FakeBackupService) ListBackupRestores(ctx context.Context, req *backupv1.ListBackupRestoresRequest) (*backupv1.ListBackupRestoresResponse, error) {
+	f.ListBackupRestoresCalls.record(req)
 	if f.ListBackupRestoresFunc != nil {
 		return f.ListBackupRestoresFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.ListBackupRestores(ctx, req)
+	return f.ListBackupRestoresCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.ListBackupRestores)
 }
 
-// RestoreBackup delegates to RestoreBackupFunc if set.
+// RestoreBackup delegates to RestoreBackupFunc if set, otherwise dispatches via RestoreBackupCalls.
 func (f *FakeBackupService) RestoreBackup(ctx context.Context, req *backupv1.RestoreBackupRequest) (*backupv1.RestoreBackupResponse, error) {
+	f.RestoreBackupCalls.record(req)
 	if f.RestoreBackupFunc != nil {
 		return f.RestoreBackupFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.RestoreBackup(ctx, req)
+	return f.RestoreBackupCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.RestoreBackup)
 }
 
-// ListBackupSchedules delegates to ListBackupSchedulesFunc if set.
+// ListBackupSchedules delegates to ListBackupSchedulesFunc if set, otherwise dispatches via ListBackupSchedulesCalls.
 func (f *FakeBackupService) ListBackupSchedules(ctx context.Context, req *backupv1.ListBackupSchedulesRequest) (*backupv1.ListBackupSchedulesResponse, error) {
+	f.ListBackupSchedulesCalls.record(req)
 	if f.ListBackupSchedulesFunc != nil {
 		return f.ListBackupSchedulesFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.ListBackupSchedules(ctx, req)
+	return f.ListBackupSchedulesCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.ListBackupSchedules)
 }
 
-// GetBackupSchedule delegates to GetBackupScheduleFunc if set.
+// GetBackupSchedule delegates to GetBackupScheduleFunc if set, otherwise dispatches via GetBackupScheduleCalls.
 func (f *FakeBackupService) GetBackupSchedule(ctx context.Context, req *backupv1.GetBackupScheduleRequest) (*backupv1.GetBackupScheduleResponse, error) {
+	f.GetBackupScheduleCalls.record(req)
 	if f.GetBackupScheduleFunc != nil {
 		return f.GetBackupScheduleFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.GetBackupSchedule(ctx, req)
+	return f.GetBackupScheduleCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.GetBackupSchedule)
 }
 
-// CreateBackupSchedule delegates to CreateBackupScheduleFunc if set.
+// CreateBackupSchedule delegates to CreateBackupScheduleFunc if set, otherwise dispatches via CreateBackupScheduleCalls.
 func (f *FakeBackupService) CreateBackupSchedule(ctx context.Context, req *backupv1.CreateBackupScheduleRequest) (*backupv1.CreateBackupScheduleResponse, error) {
+	f.CreateBackupScheduleCalls.record(req)
 	if f.CreateBackupScheduleFunc != nil {
 		return f.CreateBackupScheduleFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.CreateBackupSchedule(ctx, req)
+	return f.CreateBackupScheduleCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.CreateBackupSchedule)
 }
 
-// UpdateBackupSchedule delegates to UpdateBackupScheduleFunc if set.
+// UpdateBackupSchedule delegates to UpdateBackupScheduleFunc if set, otherwise dispatches via UpdateBackupScheduleCalls.
 func (f *FakeBackupService) UpdateBackupSchedule(ctx context.Context, req *backupv1.UpdateBackupScheduleRequest) (*backupv1.UpdateBackupScheduleResponse, error) {
+	f.UpdateBackupScheduleCalls.record(req)
 	if f.UpdateBackupScheduleFunc != nil {
 		return f.UpdateBackupScheduleFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.UpdateBackupSchedule(ctx, req)
+	return f.UpdateBackupScheduleCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.UpdateBackupSchedule)
 }
 
-// DeleteBackupSchedule delegates to DeleteBackupScheduleFunc if set.
+// DeleteBackupSchedule delegates to DeleteBackupScheduleFunc if set, otherwise dispatches via DeleteBackupScheduleCalls.
 func (f *FakeBackupService) DeleteBackupSchedule(ctx context.Context, req *backupv1.DeleteBackupScheduleRequest) (*backupv1.DeleteBackupScheduleResponse, error) {
+	f.DeleteBackupScheduleCalls.record(req)
 	if f.DeleteBackupScheduleFunc != nil {
 		return f.DeleteBackupScheduleFunc(ctx, req)
 	}
-	return f.UnimplementedBackupServiceServer.DeleteBackupSchedule(ctx, req)
+	return f.DeleteBackupScheduleCalls.dispatch(ctx, req, f.UnimplementedBackupServiceServer.DeleteBackupSchedule)
 }

internal/testutil/fake_booking.go

@@ -12,12 +12,15 @@ type FakeBookingService struct {
 	bookingv1.UnimplementedBookingServiceServer
 
 	ListPackagesFunc func(context.Context, *bookingv1.ListPackagesRequest) (*bookingv1.ListPackagesResponse, error)
+
+	ListPackagesCalls MethodSpy[*bookingv1.ListPackagesRequest, *bookingv1.ListPackagesResponse]
 }
 
-// ListPackages delegates to ListPackagesFunc if set.
+// ListPackages delegates to ListPackagesFunc if set, otherwise dispatches via ListPackagesCalls.
 func (f *FakeBookingService) ListPackages(ctx context.Context, req *bookingv1.ListPackagesRequest) (*bookingv1.ListPackagesResponse, error) {
+	f.ListPackagesCalls.record(req)
 	if f.ListPackagesFunc != nil {
 		return f.ListPackagesFunc(ctx, req)
 	}
-	return f.UnimplementedBookingServiceServer.ListPackages(ctx, req)
+	return f.ListPackagesCalls.dispatch(ctx, req, f.UnimplementedBookingServiceServer.ListPackages)
 }

internal/testutil/fake_cluster.go

@@ -21,84 +21,105 @@ type FakeClusterService struct {
 	UnsuspendClusterFunc   func(context.Context, *clusterv1.UnsuspendClusterRequest) (*clusterv1.UnsuspendClusterResponse, error)
 	SuggestClusterNameFunc func(context.Context, *clusterv1.SuggestClusterNameRequest) (*clusterv1.SuggestClusterNameResponse, error)
 	ListQdrantReleasesFunc func(context.Context, *clusterv1.ListQdrantReleasesRequest) (*clusterv1.ListQdrantReleasesResponse, error)
+
+	ListClustersCalls       MethodSpy[*clusterv1.ListClustersRequest, *clusterv1.ListClustersResponse]
+	GetClusterCalls         MethodSpy[*clusterv1.GetClusterRequest, *clusterv1.GetClusterResponse]
+	CreateClusterCalls      MethodSpy[*clusterv1.CreateClusterRequest, *clusterv1.CreateClusterResponse]
+	UpdateClusterCalls      MethodSpy[*clusterv1.UpdateClusterRequest, *clusterv1.UpdateClusterResponse]
+	DeleteClusterCalls      MethodSpy[*clusterv1.DeleteClusterRequest, *clusterv1.DeleteClusterResponse]
+	RestartClusterCalls     MethodSpy[*clusterv1.RestartClusterRequest, *clusterv1.RestartClusterResponse]
+	SuspendClusterCalls     MethodSpy[*clusterv1.SuspendClusterRequest, *clusterv1.SuspendClusterResponse]
+	UnsuspendClusterCalls   MethodSpy[*clusterv1.UnsuspendClusterRequest, *clusterv1.UnsuspendClusterResponse]
+	SuggestClusterNameCalls MethodSpy[*clusterv1.SuggestClusterNameRequest, *clusterv1.SuggestClusterNameResponse]
+	ListQdrantReleasesCalls MethodSpy[*clusterv1.ListQdrantReleasesRequest, *clusterv1.ListQdrantReleasesResponse]
 }
 
-// ListClusters delegates to ListClustersFunc if set.
+// ListClusters delegates to ListClustersFunc if set, otherwise dispatches via ListClustersCalls.
 func (f *FakeClusterService) ListClusters(ctx context.Context, req *clusterv1.ListClustersRequest) (*clusterv1.ListClustersResponse, error) {
+	f.ListClustersCalls.record(req)
 	if f.ListClustersFunc != nil {
 		return f.ListClustersFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.ListClusters(ctx, req)
+	return f.ListClustersCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.ListClusters)
 }
 
-// GetCluster delegates to GetClusterFunc if set.
+// GetCluster delegates to GetClusterFunc if set, otherwise dispatches via GetClusterCalls.
 func (f *FakeClusterService) GetCluster(ctx context.Context, req *clusterv1.GetClusterRequest) (*clusterv1.GetClusterResponse, error) {
+	f.GetClusterCalls.record(req)
 	if f.GetClusterFunc != nil {
 		return f.GetClusterFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.GetCluster(ctx, req)
+	return f.GetClusterCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.GetCluster)
 }
 
-// CreateCluster delegates to CreateClusterFunc if set.
+// CreateCluster delegates to CreateClusterFunc if set, otherwise dispatches via CreateClusterCalls.
 func (f *FakeClusterService) CreateCluster(ctx context.Context, req *clusterv1.CreateClusterRequest) (*clusterv1.CreateClusterResponse, error) {
+	f.CreateClusterCalls.record(req)
 	if f.CreateClusterFunc != nil {
 		return f.CreateClusterFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.CreateCluster(ctx, req)
+	return f.CreateClusterCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.CreateCluster)
 }
 
-// UpdateCluster delegates to UpdateClusterFunc if set.
+// UpdateCluster delegates to UpdateClusterFunc if set, otherwise dispatches via UpdateClusterCalls.
 func (f *FakeClusterService) UpdateCluster(ctx context.Context, req *clusterv1.UpdateClusterRequest) (*clusterv1.UpdateClusterResponse, error) {
+	f.UpdateClusterCalls.record(req)
 	if f.UpdateClusterFunc != nil {
 		return f.UpdateClusterFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.UpdateCluster(ctx, req)
+	return f.UpdateClusterCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.UpdateCluster)
 }
 
-// DeleteCluster delegates to DeleteClusterFunc if set.
+// DeleteCluster delegates to DeleteClusterFunc if set, otherwise dispatches via DeleteClusterCalls.
 func (f *FakeClusterService) DeleteCluster(ctx context.Context, req *clusterv1.DeleteClusterRequest) (*clusterv1.DeleteClusterResponse, error) {
+	f.DeleteClusterCalls.record(req)
 	if f.DeleteClusterFunc != nil {
 		return f.DeleteClusterFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.DeleteCluster(ctx, req)
+	return f.DeleteClusterCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.DeleteCluster)
 }
 
-// RestartCluster delegates to RestartClusterFunc if set.
+// RestartCluster delegates to RestartClusterFunc if set, otherwise dispatches via RestartClusterCalls.
 func (f *FakeClusterService) RestartCluster(ctx context.Context, req *clusterv1.RestartClusterRequest) (*clusterv1.RestartClusterResponse, error) {
+	f.RestartClusterCalls.record(req)
 	if f.RestartClusterFunc != nil {
 		return f.RestartClusterFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.RestartCluster(ctx, req)
+	return f.RestartClusterCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.RestartCluster)
 }
 
-// SuspendCluster delegates to SuspendClusterFunc if set.
+// SuspendCluster delegates to SuspendClusterFunc if set, otherwise dispatches via SuspendClusterCalls.
 func (f *FakeClusterService) SuspendCluster(ctx context.Context, req *clusterv1.SuspendClusterRequest) (*clusterv1.SuspendClusterResponse, error) {
+	f.SuspendClusterCalls.record(req)
 	if f.SuspendClusterFunc != nil {
 		return f.SuspendClusterFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.SuspendCluster(ctx, req)
+	return f.SuspendClusterCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.SuspendCluster)
 }
 
-// UnsuspendCluster delegates to UnsuspendClusterFunc if set.
+// UnsuspendCluster delegates to UnsuspendClusterFunc if set, otherwise dispatches via UnsuspendClusterCalls.
 func (f *FakeClusterService) UnsuspendCluster(ctx context.Context, req *clusterv1.UnsuspendClusterRequest) (*clusterv1.UnsuspendClusterResponse, error) {
+	f.UnsuspendClusterCalls.record(req)
 	if f.UnsuspendClusterFunc != nil {
 		return f.UnsuspendClusterFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.UnsuspendCluster(ctx, req)
+	return f.UnsuspendClusterCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.UnsuspendCluster)
 }
 
-// SuggestClusterName delegates to SuggestClusterNameFunc if set.
+// SuggestClusterName delegates to SuggestClusterNameFunc if set, otherwise dispatches via SuggestClusterNameCalls.
 func (f *FakeClusterService) SuggestClusterName(ctx context.Context, req *clusterv1.SuggestClusterNameRequest) (*clusterv1.SuggestClusterNameResponse, error) {
+	f.SuggestClusterNameCalls.record(req)
 	if f.SuggestClusterNameFunc != nil {
 		return f.SuggestClusterNameFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.SuggestClusterName(ctx, req)
+	return f.SuggestClusterNameCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.SuggestClusterName)
 }
 
-// ListQdrantReleases delegates to ListQdrantReleasesFunc if set.
+// ListQdrantReleases delegates to ListQdrantReleasesFunc if set, otherwise dispatches via ListQdrantReleasesCalls.
 func (f *FakeClusterService) ListQdrantReleases(ctx context.Context, req *clusterv1.ListQdrantReleasesRequest) (*clusterv1.ListQdrantReleasesResponse, error) {
+	f.ListQdrantReleasesCalls.record(req)
 	if f.ListQdrantReleasesFunc != nil {
 		return f.ListQdrantReleasesFunc(ctx, req)
 	}
-	return f.UnimplementedClusterServiceServer.ListQdrantReleases(ctx, req)
+	return f.ListQdrantReleasesCalls.dispatch(ctx, req, f.UnimplementedClusterServiceServer.ListQdrantReleases)
 }

internal/testutil/fake_database_api_key.go

@@ -14,28 +14,35 @@ type FakeDatabaseApiKeyService struct {
 	ListDatabaseApiKeysFunc  func(context.Context, *clusterauthv2.ListDatabaseApiKeysRequest) (*clusterauthv2.ListDatabaseApiKeysResponse, error)
 	CreateDatabaseApiKeyFunc func(context.Context, *clusterauthv2.CreateDatabaseApiKeyRequest) (*clusterauthv2.CreateDatabaseApiKeyResponse, error)
 	DeleteDatabaseApiKeyFunc func(context.Context, *clusterauthv2.DeleteDatabaseApiKeyRequest) (*clusterauthv2.DeleteDatabaseApiKeyResponse, error)
+
+	ListDatabaseApiKeysCalls  MethodSpy[*clusterauthv2.ListDatabaseApiKeysRequest, *clusterauthv2.ListDatabaseApiKeysResponse]
+	CreateDatabaseApiKeyCalls MethodSpy[*clusterauthv2.CreateDatabaseApiKeyRequest, *clusterauthv2.CreateDatabaseApiKeyResponse]
+	DeleteDatabaseApiKeyCalls MethodSpy[*clusterauthv2.DeleteDatabaseApiKeyRequest, *clusterauthv2.DeleteDatabaseApiKeyResponse]
 }
 
-// ListDatabaseApiKeys delegates to ListDatabaseApiKeysFunc if set.
+// ListDatabaseApiKeys delegates to ListDatabaseApiKeysFunc if set, otherwise dispatches via ListDatabaseApiKeysCalls.
 func (f *FakeDatabaseApiKeyService) ListDatabaseApiKeys(ctx context.Context, req *clusterauthv2.ListDatabaseApiKeysRequest) (*clusterauthv2.ListDatabaseApiKeysResponse, error) {
+	f.ListDatabaseApiKeysCalls.record(req)
 	if f.ListDatabaseApiKeysFunc != nil {
 		return f.ListDatabaseApiKeysFunc(ctx, req)
 	}
-	return f.UnimplementedDatabaseApiKeyServiceServer.ListDatabaseApiKeys(ctx, req)
+	return f.ListDatabaseApiKeysCalls.dispatch(ctx, req, f.UnimplementedDatabaseApiKeyServiceServer.ListDatabaseApiKeys)
 }
 
-// CreateDatabaseApiKey delegates to CreateDatabaseApiKeyFunc if set.
+// CreateDatabaseApiKey delegates to CreateDatabaseApiKeyFunc if set, otherwise dispatches via CreateDatabaseApiKeyCalls.
 func (f *FakeDatabaseApiKeyService) CreateDatabaseApiKey(ctx context.Context, req *clusterauthv2.CreateDatabaseApiKeyRequest) (*clusterauthv2.CreateDatabaseApiKeyResponse, error) {
+	f.CreateDatabaseApiKeyCalls.record(req)
 	if f.CreateDatabaseApiKeyFunc != nil {
 		return f.CreateDatabaseApiKeyFunc(ctx, req)
 	}
-	return f.UnimplementedDatabaseApiKeyServiceServer.CreateDatabaseApiKey(ctx, req)
+	return f.CreateDatabaseApiKeyCalls.dispatch(ctx, req, f.UnimplementedDatabaseApiKeyServiceServer.CreateDatabaseApiKey)
 }
 
-// DeleteDatabaseApiKey delegates to DeleteDatabaseApiKeyFunc if set.
+// DeleteDatabaseApiKey delegates to DeleteDatabaseApiKeyFunc if set, otherwise dispatches via DeleteDatabaseApiKeyCalls.
 func (f *FakeDatabaseApiKeyService) DeleteDatabaseApiKey(ctx context.Context, req *clusterauthv2.DeleteDatabaseApiKeyRequest) (*clusterauthv2.DeleteDatabaseApiKeyResponse, error) {
+	f.DeleteDatabaseApiKeyCalls.record(req)
 	if f.DeleteDatabaseApiKeyFunc != nil {
 		return f.DeleteDatabaseApiKeyFunc(ctx, req)
 	}
-	return f.UnimplementedDatabaseApiKeyServiceServer.DeleteDatabaseApiKey(ctx, req)
+	return f.DeleteDatabaseApiKeyCalls.dispatch(ctx, req, f.UnimplementedDatabaseApiKeyServiceServer.DeleteDatabaseApiKey)
 }