Add description in the externalised example using discriminator metadata

core/src/main/kotlin/io/specmatic/core/Feature.kt

@@ -15,6 +15,8 @@ import io.cucumber.messages.IdGenerator
 import io.cucumber.messages.IdGenerator.Incrementing
 import io.cucumber.messages.types.*
 import io.cucumber.messages.types.Examples
+import io.specmatic.core.discriminator.DiscriminatorBasedItem
+import io.specmatic.core.discriminator.DiscriminatorMetadata
 import io.specmatic.core.utilities.*
 import io.swagger.v3.oas.models.*
 import io.swagger.v3.oas.models.headers.Header
@@ -147,38 +149,44 @@ data class Feature(
         }
     }
 
-    fun generateRequestResponses(scenario: Scenario): List<GeneratedRequestResponse> {
+    fun generateDiscriminatorBasedRequestResponseList(scenario: Scenario): List<DiscriminatorBasedRequestResponse> {
         try {
             val requests = scenario.generateHttpRequestV2()
             val responses = scenario.generateHttpResponseV2(serverState)
 
-            val generatedRequestResponses = if(requests.size > responses.size) {
-                requests.map { (discriminator, request) ->
-                    val response = if(responses.containsKey(discriminator)) responses.getValue(discriminator)
-                    else responses.values.first()
-                    GeneratedRequestResponse(request, response, discriminator)
+            val discriminatorBasedRequestResponseList = if (requests.size > responses.size) {
+                requests.map { (requestDiscriminator, request) ->
+                    val (responseDiscriminator, response) = if (responses.containsDiscriminatorValueAs(requestDiscriminator.discriminatorValue))
+                        responses.getDiscriminatorItemWith(requestDiscriminator.discriminatorValue)
+                    else
+                        responses.first()
+                    DiscriminatorBasedRequestResponse(
+                        request,
+                        response,
+                        requestDiscriminator,
+                        responseDiscriminator
+                    )
                 }
             } else {
-                responses.map { (discriminator, response) ->
-                    val request = if(requests.containsKey(discriminator)) requests.getValue(discriminator)
-                        else requests.values.first()
-                    GeneratedRequestResponse(request, response, discriminator)
+                responses.map { (responseDiscriminator, response) ->
+                    val (requestDiscriminator, request) = if (requests.containsDiscriminatorValueAs(responseDiscriminator.discriminatorValue))
+                        requests.getDiscriminatorItemWith(responseDiscriminator.discriminatorValue)
+                    else requests.first()
+                    DiscriminatorBasedRequestResponse(
+                        request,
+                        response,
+                        responseDiscriminator,
+                        requestDiscriminator
+                    )
                 }
             }
 
-            return generatedRequestResponses
+            return discriminatorBasedRequestResponseList
         } finally {
             serverState = emptyMap()
         }
     }
 
-    // Better name
-    data class GeneratedRequestResponse(
-        val request: HttpRequest,
-        val response: HttpResponse,
-        val requestKind: String
-    )
-
     fun stubResponse(
         httpRequest: HttpRequest,
         mismatchMessages: MismatchMessages = DefaultMismatchMessages
@@ -1644,6 +1652,19 @@ data class Feature(
             throw ContractException(errors.joinToString("${System.lineSeparator()}${System.lineSeparator()}"))
     }
 
+    private fun<T> List<DiscriminatorBasedItem<T>>.containsDiscriminatorValueAs(
+        discriminatorValue: String
+    ): Boolean {
+        return this.any { it.discriminatorValue == discriminatorValue }
+    }
+
+    private fun <T> List<DiscriminatorBasedItem<T>>.getDiscriminatorItemWith(
+        discriminatorValue: String
+    ): DiscriminatorBasedItem<T> {
+        return this.first { it.discriminatorValue == discriminatorValue }
+    }
+
+
     companion object {
 
         private fun getTestsDirectory(contractFile: File): File? {
@@ -2223,3 +2244,10 @@ fun similarURLPath(baseScenario: Scenario, newScenario: Scenario): Boolean {
 fun isInteger(
     base: URLPathSegmentPattern
 ) = base.pattern is ExactValuePattern && base.pattern.pattern.toStringLiteral().toIntOrNull() != null
+
+data class DiscriminatorBasedRequestResponse(
+    val request: HttpRequest,
+    val response: HttpResponse,
+    val requestDiscriminator: DiscriminatorMetadata,
+    val responseDiscriminator: DiscriminatorMetadata
+)

core/src/main/kotlin/io/specmatic/core/HttpRequestPattern.kt

@@ -7,6 +7,9 @@ import io.specmatic.core.Result.Success
 import io.specmatic.core.pattern.*
 import io.specmatic.core.value.StringValue
 import io.ktor.util.*
+import io.specmatic.core.discriminator.DiscriminatorBasedItem
+import io.specmatic.core.discriminator.DiscriminatorBasedValueGenerator
+import io.specmatic.core.discriminator.DiscriminatorMetadata
 import io.specmatic.core.utilities.Flags
 import io.specmatic.core.utilities.Flags.Companion.EXTENSIBLE_QUERY_PARAMS
 import io.specmatic.core.value.JSONObjectValue
@@ -454,22 +457,22 @@ data class HttpRequestPattern(
         }
     }
 
-    fun generateV2(resolver: Resolver): Map<String, HttpRequest> {
+    fun generateV2(resolver: Resolver): List<DiscriminatorBasedItem<HttpRequest>> {
         return attempt(breadCrumb = "REQUEST") {
-            if (method == null) {
-                throw missingParam("HTTP method")
+            val baseRequest = generate(resolver)
+
+            DiscriminatorBasedValueGenerator.generateDiscriminatorBasedValues(
+                resolver,
+                body
+            ).map {
+                DiscriminatorBasedItem(
+                    discriminator = DiscriminatorMetadata(
+                        discriminatorProperty = it.discriminatorProperty,
+                        discriminatorValue = it.discriminatorValue,
+                    ),
+                    value = baseRequest.updateBody(it.value)
+                )
             }
-            val baseRequest = HttpRequest()
-                .updateMethod(method)
-                .generateAndUpdateURL(resolver)
-                .generateAndUpdateHeaders(resolver)
-                .generateAndUpdateFormFieldsValues(resolver)
-                .generateAndUpdateSecuritySchemes(resolver)
-                .generateAndUpdateMultiPartData(resolver)
-
-            generateDiscriminatorBasedValues(resolver, body).map { (discriminatorKey, generatedBody) ->
-                discriminatorKey to baseRequest.updateBody(generatedBody)
-            }.toMap()
         }
     }
 

core/src/main/kotlin/io/specmatic/core/HttpResponsePattern.kt

@@ -1,8 +1,9 @@
 package io.specmatic.core
 
+import io.specmatic.core.discriminator.DiscriminatorBasedItem
+import io.specmatic.core.discriminator.DiscriminatorBasedValueGenerator
+import io.specmatic.core.discriminator.DiscriminatorMetadata
 import io.specmatic.core.pattern.*
-import io.specmatic.core.value.JSONArrayValue
-import io.specmatic.core.value.ListValue
 import io.specmatic.core.value.StringValue
 import io.specmatic.core.value.Value
 import io.specmatic.stub.softCastValueToXML
@@ -19,28 +20,26 @@ data class HttpResponsePattern(
     constructor(response: HttpResponse) : this(HttpHeadersPattern(response.headers.mapValues { stringToPattern(it.value, it.key) }), response.status, response.body.exactMatchElseType())
 
     fun generateResponse(resolver: Resolver): HttpResponse {
-        return attempt(breadCrumb = "RESPONSE") {
-            val value = softCastValueToXML(resolver.withCyclePrevention(body, body::generate))
-            val headers = headersPattern.generate(resolver).plus(SPECMATIC_RESULT_HEADER to "success").let { headers ->
-                if ((headers.containsKey("Content-Type").not() && value.httpContentType.isBlank().not()))
-                    headers.plus("Content-Type" to value.httpContentType)
-                else headers
-            }
-            HttpResponse(status, headers, value)
-        }
+        return generateResponseWith(
+            value = resolver.withCyclePrevention(body, body::generate),
+            resolver = resolver
+        )
     }
 
-    fun generateResponseV2(resolver: Resolver): Map<String, HttpResponse> {
+    fun generateResponseV2(resolver: Resolver): List<DiscriminatorBasedItem<HttpResponse>> {
         return attempt(breadCrumb = "RESPONSE") {
-            generateDiscriminatorBasedValues(resolver, body).map { (discriminatorKey, value) ->
-                val generatedBody = softCastValueToXML(value)
-                val headers = headersPattern.generate(resolver).plus(SPECMATIC_RESULT_HEADER to "success").let { headers ->
-                    if ((headers.containsKey("Content-Type").not() && generatedBody.httpContentType.isBlank().not()))
-                        headers.plus("Content-Type" to generatedBody.httpContentType)
-                    else headers
-                }
-                discriminatorKey to HttpResponse(status, headers, generatedBody)
-            }.toMap()
+            DiscriminatorBasedValueGenerator.generateDiscriminatorBasedValues(
+                resolver,
+                body
+            ).map {
+                DiscriminatorBasedItem(
+                    discriminator = DiscriminatorMetadata(
+                        discriminatorProperty = it.discriminatorProperty,
+                        discriminatorValue = it.discriminatorValue,
+                    ),
+                    value = generateResponseWith(it.value, resolver)
+                )
+            }
         }
     }
 
@@ -195,24 +194,17 @@ data class HttpResponsePattern(
             )
         }.breadCrumb("RESPONSE").value
     }
-}
 
-fun generateDiscriminatorBasedValues(resolver: Resolver, pattern: Pattern): Map<String, Value> {
-    return resolver.withCyclePrevention(pattern) { updatedResolver ->
-        val resolvedPattern = resolvedHop(pattern, updatedResolver)
-
-        if(resolvedPattern is ListPattern) {
-            val listValuePattern = resolvedHop(resolvedPattern.pattern, updatedResolver)
-            if(listValuePattern is AnyPattern && listValuePattern.isDiscriminatorPresent()) {
-                val values = listValuePattern.generateForEveryDiscriminatorValue(updatedResolver)
-                return@withCyclePrevention values.mapValues { JSONArrayValue(listOf(it.value)) }
+    private fun generateResponseWith(value: Value, resolver: Resolver): HttpResponse {
+        return attempt(breadCrumb = "RESPONSE") {
+            val generatedBody = softCastValueToXML(value)
+            val headers = headersPattern.generate(resolver).plus(SPECMATIC_RESULT_HEADER to "success").let { headers ->
+                if ((headers.containsKey("Content-Type").not() && generatedBody.httpContentType.isBlank().not()))
+                    headers.plus("Content-Type" to generatedBody.httpContentType)
+                else headers
             }
+            HttpResponse(status, headers, generatedBody)
         }
-
-        if(resolvedPattern !is AnyPattern || resolvedPattern.isDiscriminatorPresent().not()) {
-            return@withCyclePrevention mapOf("" to resolvedPattern.generate(updatedResolver))
-        }
-        resolvedPattern.generateForEveryDiscriminatorValue(updatedResolver)
     }
 }
 

core/src/main/kotlin/io/specmatic/core/Scenario.kt

@@ -1,6 +1,7 @@
 package io.specmatic.core
 
 import io.specmatic.conversions.OpenApiSpecification
+import io.specmatic.core.discriminator.DiscriminatorBasedItem
 import io.specmatic.core.filters.ScenarioMetadata
 import io.specmatic.core.log.logger
 import io.specmatic.core.pattern.*
@@ -168,7 +169,10 @@ data class Scenario(
             httpResponsePattern.generateResponse(resolver.copy(factStore = CheckFacts(facts), context = requestContext))
         }
 
-    fun generateHttpResponseV2(actualFacts: Map<String, Value>, requestContext: Context = NoContext): Map<String, HttpResponse> =
+    fun generateHttpResponseV2(
+        actualFacts: Map<String, Value>,
+        requestContext: Context = NoContext
+    ): List<DiscriminatorBasedItem<HttpResponse>> =
         scenarioBreadCrumb(this) {
             val facts = combineFacts(expectedFacts, actualFacts, resolver)
 
@@ -230,7 +234,7 @@ data class Scenario(
             httpRequestPattern.generate(flagsBased.update(resolver.copy(factStore = CheckFacts(expectedFacts))))
         }
 
-    fun generateHttpRequestV2(flagsBased: FlagsBased = DefaultStrategies): Map<String, HttpRequest> =
+    fun generateHttpRequestV2(flagsBased: FlagsBased = DefaultStrategies): List<DiscriminatorBasedItem<HttpRequest>> =
         scenarioBreadCrumb(this) {
             httpRequestPattern.generateV2(flagsBased.update(resolver.copy(factStore = CheckFacts(expectedFacts))))
         }

core/src/main/kotlin/io/specmatic/core/discriminator/DiscriminatorBasedItem.kt

@@ -0,0 +1,9 @@
+package io.specmatic.core.discriminator
+
+data class DiscriminatorBasedItem<T>(
+    val discriminator: DiscriminatorMetadata,
+    val value: T
+) {
+    val discriminatorProperty get() = discriminator.discriminatorProperty
+    val discriminatorValue get() = discriminator.discriminatorValue
+}

core/src/main/kotlin/io/specmatic/core/discriminator/DiscriminatorBasedValueGenerator.kt

@@ -0,0 +1,41 @@
+package io.specmatic.core.discriminator
+
+import io.specmatic.core.Resolver
+import io.specmatic.core.pattern.AnyPattern
+import io.specmatic.core.pattern.ListPattern
+import io.specmatic.core.pattern.Pattern
+import io.specmatic.core.pattern.resolvedHop
+import io.specmatic.core.value.JSONArrayValue
+import io.specmatic.core.value.Value
+
+object DiscriminatorBasedValueGenerator {
+
+    fun generateDiscriminatorBasedValues(resolver: Resolver, pattern: Pattern): List<DiscriminatorBasedItem<Value>> {
+        return resolver.withCyclePrevention(pattern) { updatedResolver ->
+            val resolvedPattern = resolvedHop(pattern, updatedResolver)
+
+            if (resolvedPattern is ListPattern) {
+                val listValuePattern = resolvedHop(resolvedPattern.pattern, updatedResolver)
+                if (listValuePattern is AnyPattern && listValuePattern.isDiscriminatorPresent()) {
+                    val values = listValuePattern.generateForEveryDiscriminatorValue(updatedResolver)
+                    return@withCyclePrevention values.map {
+                        it.copy(value = JSONArrayValue(listOf(it.value)))
+                    }
+                }
+            }
+
+            if (resolvedPattern !is AnyPattern || resolvedPattern.isDiscriminatorPresent().not()) {
+                return@withCyclePrevention listOf(
+                    DiscriminatorBasedItem(
+                        discriminator = DiscriminatorMetadata(
+                            discriminatorProperty = "",
+                            discriminatorValue = "",
+                        ),
+                        value = resolvedPattern.generate(updatedResolver)
+                    )
+                )
+            }
+            resolvedPattern.generateForEveryDiscriminatorValue(updatedResolver)
+        }
+    }
+}