Stateful stub

application/src/main/kotlin/application/SpecmaticCommand.kt

@@ -30,6 +30,7 @@ import java.util.concurrent.Callable
             ExamplesCommand::class,
             SamplesCommand::class,
             StubCommand::class,
+            VirtualServiceCommand::class,
             SubscribeCommand::class,
             TestCommand::class,
             ValidateViaLogs::class,

application/src/main/kotlin/application/VirtualServiceCommand.kt

@@ -0,0 +1,126 @@
+package application
+
+import io.specmatic.core.Configuration
+import io.specmatic.core.Configuration.Companion.DEFAULT_HTTP_STUB_HOST
+import io.specmatic.core.Configuration.Companion.DEFAULT_HTTP_STUB_PORT
+import io.specmatic.core.DEFAULT_WORKING_DIRECTORY
+import io.specmatic.core.Feature
+import io.specmatic.core.log.StringLog
+import io.specmatic.core.log.consoleLog
+import io.specmatic.core.log.logger
+import io.specmatic.core.utilities.ContractPathData
+import io.specmatic.core.utilities.contractFilePathsFrom
+import io.specmatic.core.utilities.contractStubPaths
+import io.specmatic.core.utilities.exitIfAnyDoNotExist
+import io.specmatic.mock.ScenarioStub
+import io.specmatic.stub.stateful.StatefulHttpStub
+import picocli.CommandLine.Command
+import picocli.CommandLine.Option
+import java.util.concurrent.Callable
+import java.util.concurrent.CountDownLatch
+
+@Command(
+    name = "virtual-service",
+    mixinStandardHelpOptions = true,
+    description = ["Start a stateful virtual service with contract"]
+)
+class VirtualServiceCommand  : Callable<Int> {
+
+    @Option(names = ["--host"], description = ["Host for the virtual service"], defaultValue = DEFAULT_HTTP_STUB_HOST)
+    lateinit var host: String
+
+    @Option(names = ["--port"], description = ["Port for the virtual service"], defaultValue = DEFAULT_HTTP_STUB_PORT)
+    var port: Int = 0
+
+    @Option(names = ["--examples"], description = ["Directories containing JSON examples"], required = false)
+    var exampleDirs: List<String> = mutableListOf()
+
+    private val stubLoaderEngine = StubLoaderEngine()
+    private var server: StatefulHttpStub? = null
+    private val latch = CountDownLatch(1)
+    private val newLine = System.lineSeparator()
+
+    override fun call(): Int {
+        setup()
+
+        try {
+            startServer()
+        } catch(e: Exception) {
+            logger.log("An error occurred while starting the virtual service: ${e.message}")
+            return 1
+        }
+
+        return 0
+    }
+
+    private fun setup() {
+        exitIfContractPathsDoNotExist()
+        addShutdownHook()
+    }
+
+    private fun exitIfContractPathsDoNotExist() {
+        val contractPaths = contractStubPaths(Configuration.configFilePath).map { it.path }
+        exitIfAnyDoNotExist("The following specifications do not exist", contractPaths)
+    }
+
+    private fun addShutdownHook() {
+        Runtime.getRuntime().addShutdownHook(object : Thread() {
+            override fun run() {
+                try {
+                    latch.countDown()
+                    consoleLog(StringLog("Shutting down the virtual service"))
+                    server?.close()
+                } catch (e: InterruptedException) {
+                    currentThread().interrupt()
+                }
+            }
+        })
+    }
+
+    private fun stubContractPathData(): List<ContractPathData> {
+        return contractFilePathsFrom(Configuration.configFilePath, DEFAULT_WORKING_DIRECTORY) {
+                source -> source.stubContracts
+        }
+    }
+
+    private fun startServer() {
+        val stubData: List<Pair<Feature, List<ScenarioStub>>> = stubLoaderEngine.loadStubs(
+            stubContractPathData(),
+            exampleDirs,
+            Configuration.configFilePath,
+            false
+        )
+
+        server = StatefulHttpStub(
+            host,
+            port,
+            stubData.map { it.first },
+            Configuration.configFilePath,
+            stubData.flatMap { it.second }.also { it.logExamplesCachedAsSeedData() }
+        )
+        logger.log("Virtual service started on http://$host:$port")
+        latch.await()
+    }
+
+    private fun List<ScenarioStub>.logExamplesCachedAsSeedData() {
+        logger.log("${newLine}Injecting the data read from the following stub files into the stub server's state..".prependIndent("  "))
+        this.forEach { logger.log(it.filePath.orEmpty().prependIndent("  ")) }
+    }
+}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+

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

@@ -212,12 +212,7 @@ data class Feature(
         mismatchMessages: MismatchMessages = DefaultMismatchMessages
     ): Pair<ResponseBuilder?, Results> {
         try {
-            val scenarioSequence = scenarios.asSequence()
-
-            val localCopyOfServerState = serverState
-            val resultList = scenarioSequence.zip(scenarioSequence.map {
-                it.matchesStub(httpRequest, localCopyOfServerState, mismatchMessages)
-            })
+            val resultList = matchingScenarioToResultList(httpRequest, serverState, mismatchMessages)
 
             return matchingScenario(resultList)?.let {
                 Pair(ResponseBuilder(it, serverState), Results())
@@ -234,6 +229,49 @@ data class Feature(
         }
     }
 
+    fun stubResponseMap(
+        httpRequest: HttpRequest,
+        mismatchMessages: MismatchMessages = DefaultMismatchMessages,
+        unexpectedKeyCheck: UnexpectedKeyCheck
+    ): Map<Int, Pair<ResponseBuilder?, Results>> {
+        try {
+            val resultList = matchingScenarioToResultList(httpRequest, serverState, mismatchMessages, unexpectedKeyCheck)
+            val matchingScenarios = matchingScenarios(resultList)
+
+            if(matchingScenarios.toList().isEmpty()) {
+                val results = Results(
+                    resultList.map { it.second }.toList()
+                ).withoutFluff()
+                return mapOf(
+                    400 to Pair(
+                        ResponseBuilder(null, serverState),
+                        results
+                    )
+                )
+            }
+
+            return matchingScenarios.map { (status, scenario) ->
+                status to Pair(ResponseBuilder(scenario, serverState), Results())
+            }.toMap()
+
+        } finally {
+            serverState = emptyMap()
+        }
+    }
+
+    private fun matchingScenarioToResultList(
+        httpRequest: HttpRequest,
+        serverState: Map<String, Value>,
+        mismatchMessages: MismatchMessages,
+        unexpectedKeyCheck: UnexpectedKeyCheck = ValidateUnexpectedKeys
+    ): Sequence<Pair<Scenario, Result>> {
+        val scenarioSequence = scenarios.asSequence()
+
+        return scenarioSequence.zip(scenarioSequence.map {
+            it.matchesStub(httpRequest, serverState, mismatchMessages, unexpectedKeyCheck)
+        })
+    }
+
     fun compatibilityLookup(httpRequest: HttpRequest, mismatchMessages: MismatchMessages = NewAndOldContractRequestMismatches): List<Pair<Scenario, Result>> {
         try {
             val resultList = lookupAllScenarios(httpRequest, scenarios, mismatchMessages, IgnoreUnexpectedKeys)
@@ -275,6 +313,12 @@ data class Feature(
         }?.first
     }
 
+    private fun matchingScenarios(resultList: Sequence<Pair<Scenario, Result>>): Sequence<Pair<Int, Scenario>> {
+        return resultList.filter { it.second is Result.Success }.map {
+            Pair(it.first.status, it.first)
+        }
+    }
+
     private fun lookupScenario(
         httpRequest: HttpRequest,
         scenarios: List<Scenario>

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

@@ -33,6 +33,9 @@ data class HttpRequestPattern(
     val multiPartFormDataPattern: List<MultiPartFormDataPattern> = emptyList(),
     val securitySchemes: List<OpenAPISecurityScheme> = listOf(NoSecurityScheme())
 ) {
+
+    fun getPathSegmentPatterns() = httpPathPattern?.pathSegmentPatterns
+
     fun getHeaderKeys() = headersPattern.headerNames
 
     fun getQueryParamKeys() = httpQueryParamPattern.queryKeyNames

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

@@ -1,10 +1,18 @@
 package io.specmatic.core
 
+import io.specmatic.core.pattern.resolvedHop
 import io.specmatic.core.value.Value
 import io.specmatic.stub.RequestContext
 
-class ResponseBuilder(val scenario: Scenario, val serverState: Map<String, Value>) {
-    fun build(requestContext: RequestContext): HttpResponse {
-        return scenario.generateHttpResponse(serverState, requestContext)
+class ResponseBuilder(val scenario: Scenario?, val serverState: Map<String, Value>) {
+    val responseBodyPattern = scenario?.resolver?.withCyclePrevention(
+        scenario.httpResponsePattern.body
+    ) {
+        resolvedHop(scenario.httpResponsePattern.body, it)
+    }
+    val resolver = scenario?.resolver
+
+    fun build(requestContext: RequestContext): HttpResponse? {
+        return scenario?.generateHttpResponse(serverState, requestContext)
     }
 }

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

@@ -160,10 +160,16 @@ data class Scenario(
     fun matchesStub(
         httpRequest: HttpRequest,
         serverState: Map<String, Value>,
-        mismatchMessages: MismatchMessages = DefaultMismatchMessages
+        mismatchMessages: MismatchMessages = DefaultMismatchMessages,
+        unexpectedKeyCheck: UnexpectedKeyCheck? = null
     ): Result {
         val headersResolver = Resolver(serverState, false, patterns).copy(mismatchMessages = mismatchMessages)
-        val nonHeadersResolver = headersResolver.disableOverrideUnexpectedKeycheck()
+
+        val nonHeadersResolver = if(unexpectedKeyCheck != null) {
+            headersResolver.withUnexpectedKeyCheck(unexpectedKeyCheck)
+        } else {
+            headersResolver
+        }.disableOverrideUnexpectedKeycheck()
 
         return matches(httpRequest, serverState, nonHeadersResolver, headersResolver)
     }
@@ -208,6 +214,12 @@ data class Scenario(
             httpResponsePattern.generateResponseV2(updatedResolver)
         }
 
+    fun resolvedResponseBodyPattern(): Pattern {
+        return resolver.withCyclePrevention(httpResponsePattern.body) {
+            resolvedHop(httpResponsePattern.body, it)
+        }
+    }
+
     private fun combineFacts(
         expected: Map<String, Value>,
         actual: Map<String, Value>,
@@ -790,7 +802,7 @@ data class Scenario(
         )
     }
 
-    private fun getFieldsToBeMadeMandatoryBasedOnAttributeSelection(queryParams: QueryParameters?): Set<String> {
+    fun getFieldsToBeMadeMandatoryBasedOnAttributeSelection(queryParams: QueryParameters?): Set<String> {
         val defaultAttributeSelectionFields = attributeSelectionPattern.defaultFields.toSet()
         val attributeSelectionQueryParamKey =  attributeSelectionPattern.queryParamKey
 

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

@@ -76,7 +76,12 @@ fun String.loadContract(): Feature {
 data class StubConfiguration(
     val generative: Boolean? = false,
     val delayInMilliseconds: Long? = getLongValue(SPECMATIC_STUB_DELAY),
-    val dictionary: String? = getStringValue(SPECMATIC_STUB_DICTIONARY)
+    val dictionary: String? = getStringValue(SPECMATIC_STUB_DICTIONARY),
+    val includeMandatoryAndRequestedKeysInResponse: Boolean? = true
+)
+
+data class VirtualServiceConfiguration(
+    val nonPatchableKeys: Set<String> = emptySet()
 )
 
 data class WorkflowIDOperation(
@@ -113,6 +118,8 @@ data class SpecmaticConfig(
     val security: SecurityConfiguration? = null,
     val test: TestConfiguration? = TestConfiguration(),
     val stub: StubConfiguration = StubConfiguration(),
+    @field:JsonAlias("virtual_service")
+    val virtualService: VirtualServiceConfiguration = VirtualServiceConfiguration(),
     val examples: List<String> = getStringValue(EXAMPLE_DIRECTORIES)?.split(",") ?: emptyList(),
     val workflow: WorkflowConfiguration? = null,
     val ignoreInlineExamples: Boolean = getBooleanValue(Flags.IGNORE_INLINE_EXAMPLES),

core/src/main/kotlin/io/specmatic/core/pattern/AnyPattern.kt

@@ -41,6 +41,15 @@ data class AnyPattern(
         return this
     }
 
+    override fun jsonObjectPattern(resolver: Resolver): JSONObjectPattern? {
+        if (this.hasNoAmbiguousPatterns().not()) return null
+
+        val pattern = this.pattern.first { it !is NullPattern }
+        if (pattern is JSONObjectPattern) return pattern
+        if (pattern is PossibleJsonObjectPatternContainer) return pattern.jsonObjectPattern(resolver)
+        return null
+    }
+
     override fun eliminateOptionalKey(value: Value, resolver: Resolver): Value {
         val matchingPattern = pattern.find { it.matches(value, resolver) is Result.Success } ?: return value
         return matchingPattern.eliminateOptionalKey(value, resolver)

core/src/main/kotlin/io/specmatic/core/pattern/DeferredPattern.kt

@@ -34,6 +34,17 @@ data class DeferredPattern(
         return this
     }
 
+    override fun jsonObjectPattern(resolver: Resolver): JSONObjectPattern? {
+        val resolvedPattern = resolver.withCyclePrevention(this) { updatedResolver ->
+            resolvedHop(this, updatedResolver)
+        }
+        if(resolvedPattern is JSONObjectPattern) return resolvedPattern
+        if(resolvedPattern is PossibleJsonObjectPatternContainer) {
+            return resolvedPattern.jsonObjectPattern(resolver)
+        }
+        return null
+    }
+
     override fun equals(other: Any?): Boolean = when(other) {
         is DeferredPattern -> other.pattern == pattern
         else -> false

core/src/main/kotlin/io/specmatic/core/pattern/Grammar.kt

@@ -17,6 +17,13 @@ internal fun withoutOptionality(key: String): String {
     }
 }
 
+internal fun withOptionality(key: String): String {
+    return when {
+        key.endsWith(DEFAULT_OPTIONAL_SUFFIX) -> key
+        else -> "$key$DEFAULT_OPTIONAL_SUFFIX"
+    }
+}
+
 internal fun isOptional(key: String): Boolean =
     key.endsWith(DEFAULT_OPTIONAL_SUFFIX) || key.endsWith(XML_ATTR_OPTIONAL_SUFFIX)
 

core/src/main/kotlin/io/specmatic/core/pattern/JSONObjectPattern.kt

@@ -120,6 +120,10 @@ data class JSONObjectPattern(
         })
     }
 
+    override fun jsonObjectPattern(resolver: Resolver): JSONObjectPattern? {
+        return this
+    }
+
     override fun equals(other: Any?): Boolean = when (other) {
         is JSONObjectPattern -> this.pattern == other.pattern
         else -> false
@@ -393,6 +397,14 @@ data class JSONObjectPattern(
     }
 
     override val typeName: String = "json object"
+
+    fun keysInNonOptionalFormat(): Set<String> {
+        return this.pattern.map { withoutOptionality(it.key) }.toSet()
+    }
+
+    fun patternForKey(key: String): Pattern? {
+        return pattern[withoutOptionality(key)] ?: pattern[withOptionality(key)]
+    }
 }
 
 fun generate(jsonPattern: Map<String, Pattern>, resolver: Resolver, typeAlias: String?): Map<String, Value> {

core/src/main/kotlin/io/specmatic/core/pattern/ListPattern.kt

@@ -202,6 +202,10 @@ data class ListPattern(
         }
         return this
     }
+
+    override fun jsonObjectPattern(resolver: Resolver): JSONObjectPattern? {
+        return null
+    }
 }
 
 private fun withEmptyType(pattern: Pattern, resolver: Resolver): Resolver {