feat: update assertion list

core/domain/tbs/tbs_app.go

@@ -26,10 +26,10 @@ type TestBadSmell struct {
 func (a TbsApp) AnalysisPath(deps []models.JClassNode, identifiersMap map[string]models.JIdentifier) []TestBadSmell {
 	var results []TestBadSmell = nil
 
-	var identMethodMap = make(map[string]models.JMethod)
-	for _, ident := range identifiersMap {
-		for _, method := range ident.Methods {
-			identMethodMap[ident.Package + "." + ident.ClassName + "." + method.Name] = method
+	var callMethodMap = make(map[string]models.JMethod)
+	for _, clz := range deps {
+		for _, method := range clz.Methods {
+			callMethodMap[clz.Package+"."+clz.Class+"."+method.Name] = method
 		}
 	}
 
@@ -43,10 +43,12 @@ func (a TbsApp) AnalysisPath(deps []models.JClassNode, identifiersMap map[string
 			currentMethodCalls := method.MethodCalls
 			for _, methodCall := range currentMethodCalls {
 				if methodCall.Class == clz.Class {
-					jMethod := identMethodMap[getMethodCallFullPath(methodCall)]
+					jMethod := callMethodMap[getMethodCallFullPath(methodCall)]
+					if jMethod.Name != "" {
 						currentMethodCalls = append(currentMethodCalls, jMethod.MethodCalls...)
 					}
 				}
+			}
 
 			var testType = ""
 			for _, annotation := range method.Annotations {
@@ -64,9 +66,9 @@ func (a TbsApp) AnalysisPath(deps []models.JClassNode, identifiersMap map[string
 
 				checkRedundantPrintTest(clz.Path, methodCall, &results, &testType)
 				checkSleepyTest(clz.Path, methodCall, method, &results, &testType)
+				checkRedundantAssertionTest(clz.Path, methodCall, method, &results, &testType)
 
-				methodName := methodCall.MethodName
-				if hasAssertion(methodName) {
+				if hasAssertion(methodCall.MethodName) {
 					hasAssert = true
 				}
 
@@ -77,13 +79,17 @@ func (a TbsApp) AnalysisPath(deps []models.JClassNode, identifiersMap map[string
 				}
 			}
 
-			checkDuplicateAssertTest(clz, &results, methodCallMap, &testType)
+			checkDuplicateAssertTest(clz, &results, methodCallMap, method, &testType)
 		}
 	}
 
 	return results
 }
 
+func checkRedundantAssertionTest(path string, call models.JMethodCall, method models.JMethod, result *[]TestBadSmell, testType *string) {
+
+}
+
 func hasAssertion(methodName string) bool {
 	methodName = strings.ToLower(methodName)
 	assertionList := []string{
@@ -127,24 +133,28 @@ func checkUnknownTest(clz models.JClassNode, method models.JMethod, results *[]T
 	*results = append(*results, tbs)
 }
 
-func checkDuplicateAssertTest(clz models.JClassNode, results *[]TestBadSmell, methodCallMap map[string][]models.JMethodCall, testType *string) {
+func checkDuplicateAssertTest(clz models.JClassNode, results *[]TestBadSmell, methodCallMap map[string][]models.JMethodCall, method models.JMethod, testType *string) {
+	var isDuplicateAssert = false
 	for _, methodCall := range methodCallMap {
 		if len(methodCall) >= DuplicatedAssertionLimitLength {
 			methodName := methodCall[len(methodCall)-1].MethodName
 			if hasAssertion(methodName) {
+				isDuplicateAssert = true
+			}
+		}
+	}
 
+	if isDuplicateAssert {
 		*testType = "DuplicateAssertTest"
 		tbs := *&TestBadSmell{
 			FileName:    clz.Path,
 			Type:        *testType,
 			Description: "",
-					Line:        methodCall[len(methodCall)-1].StartLine,
+			Line:        method.StartLine,
 		}
 
 		*results = append(*results, tbs)
 	}
-		}
-	}
 }
 
 func getMethodCallFullPath(methodCall models.JMethodCall) string {

core/domain/tbs/tbs_app_test.go

 package tbs
 
 import (
-	"fmt"
 	. "github.com/onsi/gomega"
 	"github.com/phodal/coca/core/adapter"
 	"github.com/phodal/coca/core/adapter/call"
@@ -63,7 +62,8 @@ func TestTbsApp_DuplicateAssertTest(t *testing.T) {
 
 	result := buildTbsResult(codePath)
 
-	g.Expect(result[0].Line).To(Equal(23))
+	g.Expect(len(result)).To(Equal(1))
+	g.Expect(result[0].Line).To(Equal(9))
 	g.Expect(result[0].Type).To(Equal("DuplicateAssertTest"))
 }
 
@@ -79,6 +79,17 @@ func TestTbsApp_UnknownTest(t *testing.T) {
 	g.Expect(result[1].Type).To(Equal("UnknownTest"))
 }
 
+func TestTbsApp_RedundantAssertionTest(t *testing.T) {
+	g := NewGomegaWithT(t)
+	codePath := "../../../_fixtures/tbs/code/RedundantAssertionTest.java"
+	codePath = filepath.FromSlash(codePath)
+
+	result := buildTbsResult(codePath)
+
+	g.Expect(len(result)).To(Equal(1))
+	//g.Expect(result[0].Type).To(Equal("EmptyTest"))
+}
+
 func TestTbsApp_CreatorNotUnknownTest(t *testing.T) {
 	g := NewGomegaWithT(t)
 	codePath := "../../../_fixtures/tbs/regression/CreatorNotUnknownTest.java"
@@ -96,8 +107,7 @@ func TestTbsApp_CallAssertInClassTests(t *testing.T) {
 
 	result := buildTbsResult(codePath)
 
-	fmt.Println(result)
-	g.Expect(len(result)).To(Equal(1))
+	g.Expect(len(result)).To(Equal(0))
 }
 
 func buildTbsResult(codePath string) []TestBadSmell {