refactor: udpate for basic codes in tesintg

Author: phodal

docs/development/test-prompts.md

@@ -21,6 +21,7 @@ You MUST use given-when-then style.
   | This project uses JUnit 5, you should import `org.junit.jupiter.api.Test` and use `@Test` annotation.- You MUST use MockMvc and test API only.
 - Use appropriate Spring test annotations such as `@MockBean`, `@Autowired`, `@WebMvcTest`, `@DataJpaTest`, `@AutoConfigureTestDatabase`, `@AutoConfigureMockMvc`, `@SpringBootTest` etc.
 
+
 // here are related classes:
 // 'filePath: /Users/phodal/IdeaProjects/untitled/src/main/java/cc/unitmesh/untitled/demo/service/BlogService.java
 // class BlogService {
@@ -30,16 +31,35 @@ You MUST use given-when-then style.
 //   + public BlogPost updateBlog(Long id, BlogPost blogDto)
 //   + public void deleteBlog(Long id)
 // }
+// 'filePath: null
+// class CreateBlogRequest {
+//   
+//   
+// }
+// 'filePath: null
+// class BlogPost {
+//   id
+//   + public BlogPost(String title, String content, String author);
+//   + public BlogPost();
+//   + public void setId(Long id);
+//   + public Long getId();
+//   + public String getTitle();
+//   + public void setTitle(String title);
+//   + public String getContent();
+//   + public void setContent(String content);
+//   + public String getAuthor();
+//   + public void setAuthor(String author);
+// }
 ```java
 @ApiOperation(value = "Create a new blog")
-    @PostMapping("/")
-    public BlogPost createBlog(@RequestBody CreateBlogRequest request) {
-        CreateBlogResponse response = new CreateBlogResponse();
-        BlogPost blogPost = new BlogPost();
-        BeanUtils.copyProperties(request, blogPost);
-        BlogPost createdBlog = blogService.createBlog(blogPost);
-        BeanUtils.copyProperties(createdBlog, response);
-        return createdBlog;
-    }
+@PostMapping("/")
+public BlogPost createBlog(@RequestBody CreateBlogRequest request) {
+  CreateBlogResponse response = new CreateBlogResponse();
+  BlogPost blogPost = new BlogPost();
+  BeanUtils.copyProperties(request, blogPost);
+  BlogPost createdBlog = blogService.createBlog(blogPost);
+  BeanUtils.copyProperties(createdBlog, response);
+  return createdBlog;
+}
 ```
 Start test code with `@Test` syntax here:  

java/src/main/kotlin/cc/unitmesh/idea/context/JavaClassContextBuilder.kt

@@ -16,15 +16,11 @@ class JavaClassContextBuilder : ClassContextBuilder {
         val fields = psiElement.fields.toList()
         val methods = psiElement.methods.toList()
 
-        val destination = ArrayList<String>()
-        for (element in supers) {
-            val name = element.name
-            if (name != null) destination.add(name)
-        }
+        val superClasses = supers.mapNotNull { it.name }
 
         val usages =
             if (gatherUsages) JavaContextCollection.findUsages(psiElement as PsiNameIdentifierOwner) else emptyList()
 
-        return ClassContext(psiElement, psiElement.text, psiElement.name, methods, fields, destination, usages)
+        return ClassContext(psiElement, psiElement.text, psiElement.name, methods, fields, superClasses, usages)
     }
 }

java/src/main/kotlin/cc/unitmesh/idea/service/JavaRelatedContext.kt

@@ -68,7 +68,11 @@ object JavaRelatedContext {
             return listOf(psiClass.superClass!!, psiClass)
         }
 
-        return listOf(psiClass)
+        if (isProjectContent(psiClass)) {
+            return listOf(psiClass)
+        }
+
+        return emptyList()
     }
 
     private fun canBeRemoved(member: PsiMember): Boolean {

java/src/main/kotlin/cc/unitmesh/idea/service/JavaTypeUtil.kt

@@ -4,44 +4,46 @@ import com.intellij.psi.*
 import com.intellij.psi.impl.source.PsiClassReferenceType
 
 object JavaTypeUtil {
-    private fun resolveByType(outputType: PsiType?): MutableMap<String, PsiClass?> {
-        val resolvedClasses = mutableMapOf<String, PsiClass?>()
+    private fun resolveByType(outputType: PsiType?): Map<String, PsiClass> {
+        val resolvedClasses = mutableMapOf<String, PsiClass>()
         if (outputType is PsiClassReferenceType) {
             if (outputType.parameters.isNotEmpty()) {
                 outputType.parameters.forEach {
-                    if (it is PsiClassReferenceType) {
-                        resolvedClasses[it.canonicalText] = outputType.resolve()
+                    if (it is PsiClassReferenceType && outputType.resolve() != null) {
+                        resolvedClasses[it.canonicalText] = outputType.resolve()!!
                     }
                 }
             }
 
             val canonicalText = outputType.canonicalText
-            resolvedClasses[canonicalText] = outputType.resolve()
+            if (outputType.resolve() != null) {
+                resolvedClasses[canonicalText] = outputType.resolve()!!
+            }
         }
 
-        return resolvedClasses
+        return resolvedClasses.filter { JavaRelatedContext.isProjectContent(it.value) }.toMap()
     }
 
-    fun resolveByField(element: PsiElement): Map<out String, PsiClass?> {
+    fun resolveByField(element: PsiElement): Map<String, PsiClass> {
         val psiFile = element.containingFile as PsiJavaFile
 
-        val resolvedClasses = mutableMapOf<String, PsiClass?>()
+        val resolvedClasses = mutableMapOf<String, PsiClass>()
         psiFile.classes.forEach { psiClass ->
             psiClass.fields.forEach { field ->
                 resolvedClasses.putAll(resolveByType(field.type))
             }
         }
 
-        return resolvedClasses
+        return resolvedClasses.filter { JavaRelatedContext.isProjectContent(it.value) }.toMap()
     }
 
     /**
      * The resolved classes include all the classes in the method signature. For example, if the method signature is
      * Int, will return Int, but if the method signature is List<Int>, will return List and Int.
      * So, remember to filter out the classes that are not needed.
      */
-    fun resolveByMethod(element: PsiElement): MutableMap<String, PsiClass?> {
-        val resolvedClasses = mutableMapOf<String, PsiClass?>()
+    fun resolveByMethod(element: PsiElement): Map<String, PsiClass> {
+        val resolvedClasses = mutableMapOf<String, PsiClass>()
         if (element is PsiMethod) {
             element.parameterList.parameters.filter {
                 it.type is PsiClassReferenceType
@@ -58,6 +60,6 @@ object JavaTypeUtil {
             resolvedClasses.putAll(resolveByType(outputType))
         }
 
-        return resolvedClasses
+        return resolvedClasses.filter { JavaRelatedContext.isProjectContent(it.value) }.toMap()
     }
 }

java/src/main/kotlin/cc/unitmesh/idea/service/JavaWriteTestService.kt

@@ -94,7 +94,7 @@ class JavaWriteTestService : WriteTestService() {
             val elements = mutableListOf<ClassContext>()
             val projectPath = project.guessProjectDir()?.path
 
-            val resolvedClasses: MutableMap<String, PsiClass?> = mutableMapOf()
+            val resolvedClasses: MutableMap<String, PsiClass> = mutableMapOf()
             resolvedClasses.putAll(JavaTypeUtil.resolveByField(element))
 
             when (element) {
@@ -105,16 +105,15 @@ class JavaWriteTestService : WriteTestService() {
                 }
 
                 is PsiMethod -> {
-                    val findRelatedClassesAndCleanUp = JavaRelatedContext.findRelatedClassesAndCleanUp(element)
-                    findRelatedClassesAndCleanUp.forEach { psiClass ->
+                    JavaRelatedContext.findRelatedClassesAndCleanUp(element).forEach { psiClass ->
                         resolvedClasses[psiClass.name!!] = psiClass
                     }
                 }
             }
 
             // find the class in the same project
             resolvedClasses.forEach { (_, psiClass) ->
-                val classPath = psiClass?.containingFile?.virtualFile?.path
+                val classPath = psiClass.containingFile?.virtualFile?.path
                 if (classPath?.contains(projectPath!!) == true) {
                     elements += ClassContextProvider(false).from(psiClass)
                 }

src/main/kotlin/cc/unitmesh/devti/context/ClassContext.kt

@@ -30,7 +30,7 @@ class ClassContext(
                 "+ $method"
             }
 
-        val filePath = runReadAction { root.containingFile.virtualFile.path }
+        val filePath = runReadAction { root.containingFile?.virtualFile?.path }
 
         return """
         |'filePath: $filePath