Merge pull request #1379 from WebFuzzing/phg/supportChoiceGene

arcuri82 · web-flow · commit b8de7e72b2ab · 2025-11-04T09:47:22.000+01:00
Support for ChoiceGene in DTO generated test cases
diff --git a/core-tests/e2e-tests/spring-rest-openapi-v3/src/main/kotlin/com/foo/rest/examples/spring/openapi/v3/dtoreflectiveassert/DtoReflectiveAssertRest.kt b/core-tests/e2e-tests/spring-rest-openapi-v3/src/main/kotlin/com/foo/rest/examples/spring/openapi/v3/dtoreflectiveassert/DtoReflectiveAssertRest.kt
@@ -14,17 +14,15 @@ class DtoReflectiveAssertRest {
         return ResponseEntity.ok("OK")
     }
 
-    // TODO: Restore when support for ChoiceGene has been added
-//    @PostMapping(path = ["/anyof"], consumes = [MediaType.APPLICATION_JSON_VALUE])
-//    open fun anyof(@RequestBody body: AnyOfDto) : ResponseEntity<String>{
-//        return ResponseEntity.ok("OK")
-//    }
-
-    // TODO: Restore when support for ChoiceGene has been added
-//    @PostMapping(path = ["/oneof"], consumes = [MediaType.APPLICATION_JSON_VALUE])
-//    open fun oneof(@RequestBody body: OneOfDto) : ResponseEntity<String>{
-//        return ResponseEntity.ok("OK")
-//    }
+    @PostMapping(path = ["/anyof"], consumes = [MediaType.APPLICATION_JSON_VALUE])
+    open fun anyof(@RequestBody body: AnyOfDto) : ResponseEntity<String>{
+        return ResponseEntity.ok("OK")
+    }
+
+    @PostMapping(path = ["/oneof"], consumes = [MediaType.APPLICATION_JSON_VALUE])
+    open fun oneof(@RequestBody body: OneOfDto) : ResponseEntity<String>{
+        return ResponseEntity.ok("OK")
+    }
 
     @PostMapping(path = ["/primitiveTypes"], consumes = [MediaType.APPLICATION_JSON_VALUE])
     open fun primitiveTypes(@RequestBody body: PrimitiveTypesDto) : ResponseEntity<String>{
diff --git a/core-tests/e2e-tests/spring-rest-openapi-v3/src/main/resources/static/openapi-dto-reflective-assert.yaml b/core-tests/e2e-tests/spring-rest-openapi-v3/src/main/resources/static/openapi-dto-reflective-assert.yaml
@@ -1,6 +1,6 @@
 openapi: 3.0.3
 info:
-  title: allOf with Component Schemas
+  title: Schema for E2E DTO Testing
   version: 1.0.0
 
 paths:
@@ -126,47 +126,46 @@ paths:
       responses:
         '200':
           description: OK
-# TODO: Restore when support for ChoiceGene has been added
-#  /anyof:
-#    post:
-#      summary: Accepts either an email (component) or phone (inline)
-#      requestBody:
-#        required: true
-#        content:
-#          application/json:
-#            schema:
-#              anyOf:
-#                - $ref: '#/components/schemas/EmailPayload'
-#                - type: object
-#                  required: [phone]
-#                  properties:
-#                    phone:
-#                      type: string
-#      responses:
-#        '200':
-#          description: OK
-#  /oneof:
-#    post:
-#      summary: Accepts either cat or dog object (but not both)
-#      requestBody:
-#        required: true
-#        content:
-#          application/json:
-#            schema:
-#              oneOf:
-#                - type: object
-#                  required: [cat]
-#                  properties:
-#                    cat:
-#                      type: string
-#                - type: object
-#                  required: [mouse]
-#                  properties:
-#                    mouse:
-#                      type: string
-#      responses:
-#        '200':
-#          description: OK
+  /anyof:
+    post:
+      summary: Accepts either an email (component) or phone (inline)
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              anyOf:
+                - $ref: '#/components/schemas/EmailPayload'
+                - type: object
+                  required: [phone]
+                  properties:
+                    phone:
+                      type: string
+      responses:
+        '200':
+          description: OK
+  /oneof:
+    post:
+      summary: Accepts either cat or mouse object (but not both)
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              oneOf:
+                - type: object
+                  required: [cat]
+                  properties:
+                    cat:
+                      type: string
+                - type: object
+                  required: [mouse]
+                  properties:
+                    mouse:
+                      type: string
+      responses:
+        '200':
+          description: OK
 
 components:
   schemas:
diff --git a/core-tests/e2e-tests/spring-rest-openapi-v3/src/test/kotlin/org/evomaster/e2etests/spring/openapi/v3/dtoreflectiveassert/DtoReflectiveAssertEMTest.kt b/core-tests/e2e-tests/spring-rest-openapi-v3/src/test/kotlin/org/evomaster/e2etests/spring/openapi/v3/dtoreflectiveassert/DtoReflectiveAssertEMTest.kt
@@ -37,6 +37,8 @@ class DtoReflectiveAssertEMTest: SpringTestBase() {
 
             Assertions.assertTrue(solution.individuals.size >= 1)
             assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/allof", "OK")
+            assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/anyof", "OK")
+            assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/oneof", "OK")
             assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/primitiveTypes", "OK")
             assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/parent", "OK")
             assertHasAtLeastOne(solution, HttpVerb.POST, 200, "/items-inline", "OK")
@@ -47,9 +49,8 @@ class DtoReflectiveAssertEMTest: SpringTestBase() {
         assertParentAndChildDtosCreated()
         assertAllOfDtoCreated()
         assertItemsInlineDtoCreated()
-        // TODO: Restore when support for ChoiceGene has been added
-//        assertAnyOfDtoCreated()
-//        assertOneOfDtoCreated()
+        assertAnyOfDtoCreated()
+        assertOneOfDtoCreated()
     }
 
     private fun assertPrimitiveTypeDtoCreated() {
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
@@ -17,6 +17,7 @@ import org.evomaster.core.search.gene.placeholder.CycleObjectGene
 import org.evomaster.core.search.gene.regex.RegexGene
 import org.evomaster.core.search.gene.string.Base64StringGene
 import org.evomaster.core.search.gene.string.StringGene
+import org.evomaster.core.search.gene.wrapper.ChoiceGene
 import org.evomaster.core.search.gene.wrapper.OptionalGene
 import org.evomaster.core.utils.StringUtils
 
@@ -37,46 +38,48 @@ class GeneToDto(
     }
 
     /**
-     * @param leafGene to obtain the refType if the component is defined with a name
+     * @param gene to obtain the refType if the component is defined with a name
      * @param fallback to provide a fallback on the DTO named with the action if the component is defined inline
      * @param capitalize to determine if the DTO string name must be capitalized for test case writing
      *
      * @return the DTO name that will be used to instantiate the first variable
      */
-    fun getDtoName(leafGene: Gene, fallback: String, capitalize: Boolean): String {
-        return when (leafGene) {
-            is ObjectGene -> TestWriterUtils.safeVariableName(leafGene.refType?:fallback)
+    fun getDtoName(gene: Gene, fallback: String, capitalize: Boolean): String {
+        return when (gene) {
+            is ObjectGene -> TestWriterUtils.safeVariableName(gene.refType?:fallback)
             is ArrayGene<*> -> {
-                val template = leafGene.template
+                val template = gene.template
                 if (template is ObjectGene) {
                     TestWriterUtils.safeVariableName(template.refType?:fallback)
                 } else {
                     // TODO handle arrays of basic data types
                     return getListType(fallback, template, capitalize)
                 }
             }
-            else -> throw IllegalStateException("Gene $leafGene is not supported for DTO payloads for action: $fallback")
+            is ChoiceGene<*> -> TestWriterUtils.safeVariableName(fallback)
+            else -> throw IllegalStateException("Gene $gene is not supported for DTO payloads for action: $fallback")
         }
     }
 
     /**
      * @param gene from which to extract the setter calls
      * @param dtoName that will be instantiated for payload
-     * @param counter list to provide uniqueness under the same DTO being used in a single test case
+     * @param counters list to provide uniqueness under the same DTO being used in a single test case
      * @param capitalize to determine if the DTO string name must be capitalized for test case writing
      *
      * @return a [DtoCall] object that can be written to the test case
      */
-    fun getDtoCall(gene: Gene, dtoName: String, counter: MutableList<Int>, capitalize: Boolean): DtoCall {
+    fun getDtoCall(gene: Gene, dtoName: String, counters: MutableList<Int>, capitalize: Boolean): DtoCall {
         return when(gene) {
-            is ObjectGene -> getObjectDtoCall(gene, dtoName, counter, capitalize)
-            is ArrayGene<*> -> getArrayDtoCall(gene, dtoName, counter, null, capitalize)
+            is ObjectGene -> getObjectDtoCall(gene, dtoName, counters)
+            is ArrayGene<*> -> getArrayDtoCall(gene, dtoName, counters, null, capitalize)
+            is ChoiceGene<*> -> getDtoCall(gene.activeGene(), dtoName, counters, capitalize)
             else -> throw RuntimeException("BUG: Gene $gene (with type ${this::class.java.simpleName}) should not be creating DTOs")
         }
     }
 
-    private fun getObjectDtoCall(gene: ObjectGene, dtoName: String, counter: MutableList<Int>, capitalize: Boolean): DtoCall {
-        val dtoVarName = "dto_${dtoName}_${counter.joinToString("_")}"
+    private fun getObjectDtoCall(gene: ObjectGene, dtoName: String, counters: MutableList<Int>): DtoCall {
+        val dtoVarName = "dto_${dtoName}_${counters.joinToString("_")}"
 
         val result = mutableListOf<String>()
         result.add(dtoOutput.getNewObjectStatement(dtoName, dtoVarName))
@@ -90,13 +93,13 @@ class GeneToDto(
             val attributeName = it.name
             when (leafGene) {
                 is ObjectGene -> {
-                    val childDtoCall = getDtoCall(leafGene, getDtoName(leafGene, attributeName, true), counter, true)
+                    val childDtoCall = getDtoCall(leafGene, getDtoName(leafGene, attributeName, true), counters, true)
 
                     result.addAll(childDtoCall.objectCalls)
                     result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, childDtoCall.varName))
                 }
                 is ArrayGene<*> -> {
-                    val childDtoCall = getArrayDtoCall(leafGene, getDtoName(leafGene, attributeName, true), counter, attributeName, true)
+                    val childDtoCall = getArrayDtoCall(leafGene, getDtoName(leafGene, attributeName, true), counters, attributeName, true)
 
                     result.addAll(childDtoCall.objectCalls)
                     result.add(dtoOutput.getSetterStatement(dtoVarName, attributeName, childDtoCall.varName))
@@ -110,20 +113,20 @@ class GeneToDto(
         return DtoCall(dtoVarName, result)
     }
 
-    private fun getArrayDtoCall(gene: ArrayGene<*>, dtoName: String, counter: MutableList<Int>, targetAttribute: String?, capitalize: Boolean): DtoCall {
+    private fun getArrayDtoCall(gene: ArrayGene<*>, dtoName: String, counters: MutableList<Int>, targetAttribute: String?, capitalize: Boolean): DtoCall {
         val result = mutableListOf<String>()
         val template = gene.template
 
         val listType = getListType(dtoName,template, capitalize)
-        val listVarName = "list_${targetAttribute?:dtoName}_${counter.joinToString("_")}"
+        val listVarName = "list_${targetAttribute?:dtoName}_${counters.joinToString("_")}"
         result.add(dtoOutput.getNewListStatement(listType, listVarName))
 
         if (template is ObjectGene) {
             val childDtoName = template.refType?: if (capitalize) StringUtils.capitalization(dtoName) else dtoName
             var listCounter = 1
             gene.getViewOfElements().forEach {
                 val childCounter = mutableListOf<Int>()
-                childCounter.addAll(counter)
+                childCounter.addAll(counters)
                 childCounter.add(listCounter++)
                 val childDtoCall = getDtoCall(it,childDtoName, childCounter, true)
                 result.addAll(childDtoCall.objectCalls)
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
@@ -9,6 +9,7 @@ import org.evomaster.core.output.TestWriterUtils
 import org.evomaster.core.output.TestWriterUtils.formatJsonWithEscapes
 import org.evomaster.core.output.auth.CookieWriter
 import org.evomaster.core.output.auth.TokenWriter
+import org.evomaster.core.output.dto.DtoCall
 import org.evomaster.core.output.dto.GeneToDto
 import org.evomaster.core.problem.enterprise.EnterpriseActionGroup
 import org.evomaster.core.problem.externalservice.httpws.HttpExternalServiceAction
@@ -23,6 +24,7 @@ import org.evomaster.core.search.FitnessValue
 import org.evomaster.core.search.action.Action
 import org.evomaster.core.search.action.ActionResult
 import org.evomaster.core.search.action.EvaluatedAction
+import org.evomaster.core.search.gene.Gene
 import org.evomaster.core.search.gene.ObjectGene
 import org.evomaster.core.search.gene.collection.ArrayGene
 import org.evomaster.core.search.gene.utils.GeneUtils
@@ -127,32 +129,37 @@ abstract class HttpWsTestCaseWriter : ApiTestCaseWriter() {
             val choiceGene = primaryGene.getWrappedGene(ChoiceGene::class.java)
             val actionName = call.getName()
             if (choiceGene != null) {
-                // TODO add support for payloads from choice genes
+                // We only generate DTOs for ChoiceGene objects that contain either an ObjectGene or ArrayGene in their
+                // genes. This check is necessary since when using `example` and `default` entries,
+                // "primitive" genes are represented as ChoiceGene with  an EnumGene and the actual
+                // String/Integer/Number/etc gene
                 if (hasObjectOrArrayGene(choiceGene)) {
-                    // this because when using `example` and `default` entries, "primitive" genes are represented as ChoiceGene with
-                    // an EnumGene and the actual String/Integer/Number/etc gene
-                    throw IllegalStateException("Choice genes not yet supported for dto payload")
+                    return generateDtoCall(choiceGene, actionName, lines).varName
                 }
             } else {
                 val leafGene = primaryGene.getLeafGene()
                 if (leafGene is ObjectGene || leafGene is ArrayGene<*>) {
-                    val geneToDto = GeneToDto(format)
-
-                    val dtoName = geneToDto.getDtoName(leafGene, actionName, false)
-                    val dtoCall = geneToDto.getDtoCall(leafGene, dtoName, mutableListOf(counter++), false)
-
-                    dtoCall.objectCalls.forEach {
-                        lines.add(it)
-                    }
-                    lines.addEmpty()
-                    return dtoCall.varName
+                    return generateDtoCall(leafGene, actionName, lines).varName
                 }
             }
 
         }
         return ""
     }
 
+    private fun generateDtoCall(gene: Gene, actionName: String, lines: Lines): DtoCall {
+        val geneToDto = GeneToDto(format)
+
+        val dtoName = geneToDto.getDtoName(gene, actionName, false)
+        val dtoCall = geneToDto.getDtoCall(gene, dtoName, mutableListOf(counter++), false)
+
+        dtoCall.objectCalls.forEach {
+            lines.add(it)
+        }
+        lines.addEmpty()
+        return dtoCall
+    }
+
     private fun hasObjectOrArrayGene(gene: ChoiceGene<*>): Boolean {
         return gene.getViewOfChildren().any { it is ObjectGene || it is ArrayGene<*> }
     }
