Merge pull request #1343 from WebFuzzing/phg/dtoFixesWFD

arcuri82 · web-flow · commit 0baef1ff5304 · 2025-10-09T14:37:52.000+02:00
Bug fixing in DTOs
diff --git a/core/src/main/kotlin/org/evomaster/core/output/dto/DtoWriter.kt b/core/src/main/kotlin/org/evomaster/core/output/dto/DtoWriter.kt
@@ -59,7 +59,7 @@ class DtoWriter(
     private fun calculateDtos(actionDefinitions: List<Action>) {
         actionDefinitions.forEach { action ->
             action.getViewOfChildren().find { it is BodyParam }
-            .let {
+            ?.let {
                 val primaryGene = (it as BodyParam).primaryGene()
                 val choiceGene = primaryGene.getWrappedGene(ChoiceGene::class.java)
                 if (choiceGene != null) {
diff --git a/core/src/main/kotlin/org/evomaster/core/output/dto/GeneToDto.kt b/core/src/main/kotlin/org/evomaster/core/output/dto/GeneToDto.kt
@@ -38,23 +38,23 @@ class GeneToDto(
 
     /**
      * @param leafGene to obtain the refType if the component is defined with a name
-     * @param actionName to provide a fallback on the DTO named with the action if the component is defined inline
+     * @param fallback to provide a fallback on the DTO named with the action if the component is defined inline
      *
      * @return the DTO name that will be used to instantiate the first variable
      */
-    fun getRootDtoName(leafGene: Gene, actionName: String): String {
+    fun getDtoName(leafGene: Gene, fallback: String): String {
         return when (leafGene) {
-            is ObjectGene -> leafGene.refType?:TestWriterUtils.safeVariableName(actionName)
+            is ObjectGene -> leafGene.refType?:StringUtils.capitalization(TestWriterUtils.safeVariableName(fallback))
             is ArrayGene<*> -> {
                 val template = leafGene.template
                 if (template is ObjectGene) {
-                    template.refType?:TestWriterUtils.safeVariableName(actionName)
+                    template.refType?:StringUtils.capitalization(TestWriterUtils.safeVariableName(fallback))
                 } else {
                     // TODO handle arrays of basic data types
-                    return getListType(actionName, template)
+                    return getListType(fallback, template)
                 }
             }
-            else -> throw IllegalStateException("Gene $leafGene is not supported for DTO payloads for action: $actionName")
+            else -> throw IllegalStateException("Gene $leafGene is not supported for DTO payloads for action: $fallback")
         }
     }
 
@@ -68,7 +68,7 @@ class GeneToDto(
     fun getDtoCall(gene: Gene, dtoName: String, counter: Int): DtoCall {
         return when(gene) {
             is ObjectGene -> getObjectDtoCall(gene, dtoName, counter)
-            is ArrayGene<*> -> getArrayDtoCall(gene, dtoName, counter)
+            is ArrayGene<*> -> getArrayDtoCall(gene, dtoName, counter, null)
             else -> throw RuntimeException("BUG: Gene $gene (with type ${this::class.java.simpleName}) should not be creating DTOs")
         }
     }
@@ -88,36 +88,36 @@ class GeneToDto(
             val attributeName = it.name
             when (leafGene) {
                 is ObjectGene -> {
-                    val childDtoCall = getDtoCall(leafGene, StringUtils.capitalization(attributeName), counter)
+                    val childDtoCall = getDtoCall(leafGene, getDtoName(leafGene, attributeName), counter)
 
                     result.addAll(childDtoCall.objectCalls)
                     result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, childDtoCall.varName))
                 }
                 is ArrayGene<*> -> {
-                    val childDtoCall = getDtoCall(leafGene, StringUtils.capitalization(attributeName), counter)
+                    val childDtoCall = getArrayDtoCall(leafGene, getDtoName(leafGene, attributeName), counter, attributeName)
 
                     result.addAll(childDtoCall.objectCalls)
                     result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, childDtoCall.varName))
                 }
                 else -> {
-                    result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, it.getValueAsPrintableString(targetFormat = null)))
+                    result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, "${leafGene.getValueAsPrintableString(targetFormat = null)}${getValueSuffix(leafGene)}"))
                 }
             }
         }
 
         return DtoCall(dtoVarName, result)
     }
 
-    private fun getArrayDtoCall(gene: ArrayGene<*>, dtoName: String, counter: Int): DtoCall {
+    private fun getArrayDtoCall(gene: ArrayGene<*>, dtoName: String, counter: Int, targetAttribute: String?): DtoCall {
         val result = mutableListOf<String>()
         val template = gene.template
 
         val listType = getListType(dtoName,template)
-        val listVarName = "list_${listType}_${counter}"
+        val listVarName = "list_${targetAttribute?:dtoName}_${counter}"
         result.add(dtoOutput.getNewListStatement(listType, listVarName))
 
         if (template is ObjectGene) {
-            val childDtoName = StringUtils.capitalization(template.refType?: gene.name)
+            val childDtoName = template.refType?:StringUtils.capitalization(gene.name)
             var listCounter = 1
             gene.getViewOfElements().forEach {
                 val childDtoCall = getDtoCall(it,childDtoName, listCounter++)
@@ -126,7 +126,8 @@ class GeneToDto(
             }
         } else {
             gene.getViewOfElements().forEach {
-                result.add(dtoOutput.getAddElementToListStatement(listVarName, it.getValueAsPrintableString(targetFormat = null)))
+                val leafGene = it.getLeafGene()
+                result.add(dtoOutput.getAddElementToListStatement(listVarName, "${leafGene.getValueAsPrintableString(targetFormat = null)}${getValueSuffix(leafGene)}"))
             }
         }
 
@@ -152,4 +153,14 @@ class GeneToDto(
             else -> throw Exception("Not supported gene at the moment: ${gene?.javaClass?.simpleName} for field $fieldName")
         }
     }
+
+    // According to documentation, a trailing constant is only needed for Long, Hexadecimal and Float
+    // https://kotlinlang.org/docs/numbers.html#literal-constants-for-numbers
+    private fun getValueSuffix(gene: Gene): String {
+        return when (gene) {
+            is LongGene -> "L"
+            is FloatGene -> "f"
+            else -> ""
+        }
+    }
 }
diff --git a/core/src/main/kotlin/org/evomaster/core/output/dto/JvmDtoOutput.kt b/core/src/main/kotlin/org/evomaster/core/output/dto/JvmDtoOutput.kt
@@ -15,6 +15,7 @@ abstract class JvmDtoOutput: DtoOutput {
     }
 
     protected fun addImports(lines: Lines) {
+        lines.addStatement("import java.util.List")
         lines.addStatement("import java.util.Optional")
         lines.addEmpty()
         lines.addStatement("import com.fasterxml.jackson.annotation.JsonInclude")
diff --git a/core/src/main/kotlin/org/evomaster/core/output/service/HttpWsTestCaseWriter.kt b/core/src/main/kotlin/org/evomaster/core/output/service/HttpWsTestCaseWriter.kt
@@ -136,7 +136,7 @@ abstract class HttpWsTestCaseWriter : ApiTestCaseWriter() {
                 if (leafGene is ObjectGene || leafGene is ArrayGene<*>) {
                     val geneToDto = GeneToDto(format)
 
-                    val dtoName = geneToDto.getRootDtoName(leafGene, actionName)
+                    val dtoName = geneToDto.getDtoName(leafGene, actionName)
                     val dtoCall = geneToDto.getDtoCall(leafGene, dtoName, counter++)
 
                     dtoCall.objectCalls.forEach {
diff --git a/core/src/test/kotlin/org/evomaster/core/output/dto/DtoWriterTest.kt b/core/src/test/kotlin/org/evomaster/core/output/dto/DtoWriterTest.kt
@@ -345,6 +345,16 @@ class DtoWriterTest {
         }
     }
 
+    @Test
+    fun noDtosWhenNoBodyParam() {
+        val dtoWriter = DtoWriter(outputFormat)
+        val actionCluster = initRestSchema("noBody.yaml")
+
+        dtoWriter.write(outputTestSuitePath, TEST_PACKAGE, actionCluster.values.map { it.copy() })
+
+        assertEquals(dtoWriter.getCollectedDtos().size, 0)
+    }
+
     private fun initRestSchema(openApiLocation: String) : Map<String, Action> {
         val restSchema = RestSchema(OpenApiAccess.getOpenAPIFromResource("/swagger/dto-writer/$openApiLocation"))
         val actionCluster = mutableMapOf<String, Action>()
diff --git a/core/src/test/resources/swagger/dto-writer/noBody.yaml b/core/src/test/resources/swagger/dto-writer/noBody.yaml
@@ -0,0 +1,22 @@
+openapi: 3.0.0
+info:
+  title: No body API
+  version: 1.0.0
+servers:
+  - url: http://localhost:5000
+paths:
+  /example:
+    get:
+      summary: Example with no body params
+      parameters:
+        - in: query
+          name: aQueryParam
+          schema:
+            type: string
+        - in: header
+          name: aHeaderParam
+          schema:
+            type: string
+      responses:
+        '200':
+          description: OK
diff --git a/e2e-tests/spring-rest-openapi-v3/src/main/resources/static/openapi-dto.yml b/e2e-tests/spring-rest-openapi-v3/src/main/resources/static/openapi-dto.yml
@@ -128,6 +128,8 @@ components:
           type: integer
         address:
           $ref: "#/components/schemas/Address"
+        key:
+          $ref: "#/components/schemas/SuperKey"
       required:
         - name
         - age
@@ -144,3 +146,10 @@ components:
       required:
         - street
         - country
+    SuperKey:
+      type: object
+      properties:
+        key:
+          type: string
+        value:
+          type: string

Original file line number	Diff line number	Diff line change
`@@ -38,23 +38,23 @@ class GeneToDto(`
`38`	`38`
`39`	`39`	`/**`
`40`	`40`	`* @param leafGene to obtain the refType if the component is defined with a name`
`41`		`- * @param actionName to provide a fallback on the DTO named with the action if the component is defined inline`
	`41`	`+ * @param fallback to provide a fallback on the DTO named with the action if the component is defined inline`
`42`	`42`	`*`
`43`	`43`	`* @return the DTO name that will be used to instantiate the first variable`
`44`	`44`	`*/`
`45`		`- fun getRootDtoName(leafGene: Gene, actionName: String): String {`
	`45`	`+ fun getDtoName(leafGene: Gene, fallback: String): String {`
`46`	`46`	`return when (leafGene) {`
`47`		`- is ObjectGene -> leafGene.refType?:TestWriterUtils.safeVariableName(actionName)`
	`47`	`+ is ObjectGene -> leafGene.refType?:StringUtils.capitalization(TestWriterUtils.safeVariableName(fallback))`
`48`	`48`	`is ArrayGene<*> -> {`
`49`	`49`	`val template = leafGene.template`
`50`	`50`	`if (template is ObjectGene) {`
`51`		`- template.refType?:TestWriterUtils.safeVariableName(actionName)`
	`51`	`+ template.refType?:StringUtils.capitalization(TestWriterUtils.safeVariableName(fallback))`
`52`	`52`	`} else {`
`53`	`53`	`// TODO handle arrays of basic data types`
`54`		`- return getListType(actionName, template)`
	`54`	`+ return getListType(fallback, template)`
`55`	`55`	`}`
`56`	`56`	`}`
`57`		`- else -> throw IllegalStateException("Gene $leafGene is not supported for DTO payloads for action: $actionName")`
	`57`	`+ else -> throw IllegalStateException("Gene $leafGene is not supported for DTO payloads for action: $fallback")`
`58`	`58`	`}`
`59`	`59`	`}`
`60`	`60`
`@@ -68,7 +68,7 @@ class GeneToDto(`
`68`	`68`	`fun getDtoCall(gene: Gene, dtoName: String, counter: Int): DtoCall {`
`69`	`69`	`return when(gene) {`
`70`	`70`	`is ObjectGene -> getObjectDtoCall(gene, dtoName, counter)`
`71`		`- is ArrayGene<*> -> getArrayDtoCall(gene, dtoName, counter)`
	`71`	`+ is ArrayGene<*> -> getArrayDtoCall(gene, dtoName, counter, null)`
`72`	`72`	`else -> throw RuntimeException("BUG: Gene $gene (with type ${this::class.java.simpleName}) should not be creating DTOs")`
`73`	`73`	`}`
`74`	`74`	`}`
`@@ -88,36 +88,36 @@ class GeneToDto(`
`88`	`88`	`val attributeName = it.name`
`89`	`89`	`when (leafGene) {`
`90`	`90`	`is ObjectGene -> {`
`91`		`- val childDtoCall = getDtoCall(leafGene, StringUtils.capitalization(attributeName), counter)`
	`91`	`+ val childDtoCall = getDtoCall(leafGene, getDtoName(leafGene, attributeName), counter)`
`92`	`92`
`93`	`93`	`result.addAll(childDtoCall.objectCalls)`
`94`	`94`	`result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, childDtoCall.varName))`
`95`	`95`	`}`
`96`	`96`	`is ArrayGene<*> -> {`
`97`		`- val childDtoCall = getDtoCall(leafGene, StringUtils.capitalization(attributeName), counter)`
	`97`	`+ val childDtoCall = getArrayDtoCall(leafGene, getDtoName(leafGene, attributeName), counter, attributeName)`
`98`	`98`
`99`	`99`	`result.addAll(childDtoCall.objectCalls)`
`100`	`100`	`result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, childDtoCall.varName))`
`101`	`101`	`}`
`102`	`102`	`else -> {`
`103`		`- result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, it.getValueAsPrintableString(targetFormat = null)))`
	`103`	`+ result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, "${leafGene.getValueAsPrintableString(targetFormat = null)}${getValueSuffix(leafGene)}"))`
`104`	`104`	`}`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`108`	`108`	`return DtoCall(dtoVarName, result)`
`109`	`109`	`}`
`110`	`110`
`111`		`- private fun getArrayDtoCall(gene: ArrayGene<*>, dtoName: String, counter: Int): DtoCall {`
	`111`	`+ private fun getArrayDtoCall(gene: ArrayGene<*>, dtoName: String, counter: Int, targetAttribute: String?): DtoCall {`
`112`	`112`	`val result = mutableListOf<String>()`
`113`	`113`	`val template = gene.template`
`114`	`114`
`115`	`115`	`val listType = getListType(dtoName,template)`
`116`		`- val listVarName = "list_${listType}_${counter}"`
	`116`	`+ val listVarName = "list_${targetAttribute?:dtoName}_${counter}"`
`117`	`117`	`result.add(dtoOutput.getNewListStatement(listType, listVarName))`
`118`	`118`
`119`	`119`	`if (template is ObjectGene) {`
`120`		`- val childDtoName = StringUtils.capitalization(template.refType?: gene.name)`
	`120`	`+ val childDtoName = template.refType?:StringUtils.capitalization(gene.name)`
`121`	`121`	`var listCounter = 1`
`122`	`122`	`gene.getViewOfElements().forEach {`
`123`	`123`	`val childDtoCall = getDtoCall(it,childDtoName, listCounter++)`
`@@ -126,7 +126,8 @@ class GeneToDto(`
`126`	`126`	`}`
`127`	`127`	`} else {`
`128`	`128`	`gene.getViewOfElements().forEach {`
`129`		`- result.add(dtoOutput.getAddElementToListStatement(listVarName, it.getValueAsPrintableString(targetFormat = null)))`
	`129`	`+ val leafGene = it.getLeafGene()`
	`130`	`+ result.add(dtoOutput.getAddElementToListStatement(listVarName, "${leafGene.getValueAsPrintableString(targetFormat = null)}${getValueSuffix(leafGene)}"))`
`130`	`131`	`}`
`131`	`132`	`}`
`132`	`133`
`@@ -152,4 +153,14 @@ class GeneToDto(`
`152`	`153`	`else -> throw Exception("Not supported gene at the moment: ${gene?.javaClass?.simpleName} for field $fieldName")`
`153`	`154`	`}`
`154`	`155`	`}`
	`156`	`+`
	`157`	`+ // According to documentation, a trailing constant is only needed for Long, Hexadecimal and Float`
	`158`	`+ // https://kotlinlang.org/docs/numbers.html#literal-constants-for-numbers`
	`159`	`+ private fun getValueSuffix(gene: Gene): String {`
	`160`	`+ return when (gene) {`
	`161`	`+ is LongGene -> "L"`
	`162`	`+ is FloatGene -> "f"`
	`163`	`+ else -> ""`
	`164`	`+ }`
	`165`	`+ }`
`155`	`166`	`}`
Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ abstract class JvmDtoOutput: DtoOutput {`
`15`	`15`	`}`
`16`	`16`
`17`	`17`	`protected fun addImports(lines: Lines) {`
	`18`	`+ lines.addStatement("import java.util.List")`
`18`	`19`	`lines.addStatement("import java.util.Optional")`
`19`	`20`	`lines.addEmpty()`
`20`	`21`	`lines.addStatement("import com.fasterxml.jackson.annotation.JsonInclude")`