Refactor FlutterStudioProjectOpenProcessor to improve openProjectAsync robustness with a project fallback mechanism, extracting helper methods, and adding a unit test. (#8681)

Follow up on: #8629
Related issue: #8661

Author: jwren

src/io/flutter/editor/FlutterStudioProjectOpenProcessor.kt

@@ -24,7 +24,7 @@ import io.flutter.utils.FlutterModuleUtils
  *
  * Converted to Kotlin to support `openProjectAsync`.
  */
-class FlutterStudioProjectOpenProcessor : FlutterProjectOpenProcessor() {
+open class FlutterStudioProjectOpenProcessor : FlutterProjectOpenProcessor() {
   override val name: String
     get() = "Flutter Studio"
 
@@ -50,23 +50,38 @@ class FlutterStudioProjectOpenProcessor : FlutterProjectOpenProcessor() {
     val project = importProvider.openProjectAsync(virtualFile, projectToClose, forceOpenInNewFrame)
 
     // A callback may have caused the project to be reloaded. Find the new Project object.
-    val newProject = FlutterUtils.findProject(virtualFile.path)
+    var newProject = findProject(virtualFile.path)
     if (newProject == null || newProject.isDisposed) {
-      return newProject
+      // Fallback to the original project if re-lookup fails.
+      if (project != null && !project.isDisposed) {
+        newProject = project
+      } else {
+        return null
+      }
     }
 
-    for (module in FlutterModuleUtils.getModules(newProject)) {
+    configureFlutterProject(newProject)
+    
+    return newProject
+  }
+
+  @org.jetbrains.annotations.VisibleForTesting
+  protected open suspend fun configureFlutterProject(project: Project) {
+    for (module in FlutterModuleUtils.getModules(project)) {
       if (FlutterModuleUtils.declaresFlutter(module) && !FlutterModuleUtils.isFlutterModule(module)) {
         writeAction {
           FlutterModuleUtils.setFlutterModuleType(module)
         }
         FlutterModuleUtils.enableDartSDK(module)
       }
     }
-    newProject.save()
-    EditorNotifications.getInstance(newProject).updateAllNotifications()
-    
-    return newProject
+    project.save()
+    EditorNotifications.getInstance(project).updateAllNotifications()
+  }
+
+  @org.jetbrains.annotations.VisibleForTesting
+  protected open fun findProject(path: String): Project? {
+    return FlutterUtils.findProject(path)
   }
 
   override fun doOpenProject(

testSrc/unit/io/flutter/editor/FlutterStudioProjectOpenProcessorTest.kt

@@ -0,0 +1,60 @@
+package io.flutter.editor
+
+import com.intellij.openapi.project.Project
+import com.intellij.openapi.vfs.VirtualFile
+import com.intellij.projectImport.ProjectOpenProcessor
+import kotlinx.coroutines.runBlocking
+import org.junit.Assert
+import org.junit.Test
+import org.mockito.Mockito
+
+class FlutterStudioProjectOpenProcessorTest {
+  @Test
+  fun testOpenProjectAsyncFallsBackWhenFindProjectFails() = runBlocking {
+    // Setup
+    val mockProject = Mockito.mock(Project::class.java)
+    val mockVirtualFile = Mockito.mock(VirtualFile::class.java)
+    Mockito.`when`(mockVirtualFile.path).thenReturn("/path/to/project")
+    Mockito.`when`(mockProject.isDisposed).thenReturn(false)
+
+    val fakeDelegate = object : ProjectOpenProcessor() {
+      override val name: String = "Fake"
+      override fun canOpenProject(file: VirtualFile): Boolean = true
+      override fun doOpenProject(
+        virtualFile: VirtualFile,
+        projectToClose: Project?,
+        forceOpenInNewFrame: Boolean
+      ): Project? = mockProject
+
+      override suspend fun openProjectAsync(
+        virtualFile: VirtualFile,
+        projectToClose: Project?,
+        forceOpenInNewFrame: Boolean
+      ): Project? {
+        return mockProject
+      }
+    }
+
+    val processor = object : FlutterStudioProjectOpenProcessor() {
+      override fun getDelegateImportProvider(file: VirtualFile): ProjectOpenProcessor? {
+        return fakeDelegate
+      }
+
+      override fun findProject(path: String): Project? {
+        return null // Simulate failure to find project
+      }
+
+      override suspend fun configureFlutterProject(project: Project) {
+        // No-op for test to avoid dependency on static FlutterModuleUtils
+      }
+    }
+
+    // Execution
+    val result = processor.openProjectAsync(mockVirtualFile, null, false)
+
+    // Verification
+    // If the fix works, it should fallback to mockProject
+    // If the fix is absent, it would return null (because findProject returned null)
+    Assert.assertEquals(mockProject, result)
+  }
+}