diff --git a/runner/src/integrationTest/kotlin/com/cosmotech/runner/service/RunnerServiceIntegrationTest.kt b/runner/src/integrationTest/kotlin/com/cosmotech/runner/service/RunnerServiceIntegrationTest.kt index 325f1f034..c4ed03527 100644 --- a/runner/src/integrationTest/kotlin/com/cosmotech/runner/service/RunnerServiceIntegrationTest.kt +++ b/runner/src/integrationTest/kotlin/com/cosmotech/runner/service/RunnerServiceIntegrationTest.kt @@ -218,6 +218,72 @@ class RunnerServiceIntegrationTest : CsmRedisTestBase() { assertEquals(0, runnerWithNullDatasetListSaved.datasetList!!.size) } + @Test + fun `test createRunner and check parameterValues data`() { + + logger.info( + "should create a new Runner and retrieve parameter varType from solution ignoring the one declared") + val newRunner = + makeRunner( + organizationSaved.id!!, + workspaceSaved.id!!, + solutionSaved.id!!, + "NewRunner", + mutableListOf(datasetSaved.id!!), + parametersValues = + mutableListOf( + RunnerRunTemplateParameterValue( + parameterId = "param1", value = "7", varType = "ignored_var_type"))) + val newRunnerSaved = + runnerApiService.createRunner(organizationSaved.id!!, workspaceSaved.id!!, newRunner) + + assertNotNull(newRunnerSaved.parametersValues) + assertTrue(newRunnerSaved.parametersValues!!.size == 1) + assertEquals("param1", newRunnerSaved.parametersValues!![0].parameterId) + assertEquals("7", newRunnerSaved.parametersValues!![0].value) + assertEquals("integer", newRunnerSaved.parametersValues!![0].varType) + } + + @Test + fun `test updateRunner and check parameterValues data`() { + + logger.info( + "should create a new Runner and retrieve parameter varType from solution ignoring the one declared") + val creationParameterValue = + RunnerRunTemplateParameterValue( + parameterId = "param1", value = "7", varType = "ignored_var_type") + val newRunner = + makeRunner( + organizationSaved.id!!, + workspaceSaved.id!!, + solutionSaved.id!!, + "NewRunner", + mutableListOf(datasetSaved.id!!), + parametersValues = mutableListOf(creationParameterValue)) + val newRunnerSaved = + runnerApiService.createRunner(organizationSaved.id!!, workspaceSaved.id!!, newRunner) + + assertNotNull(newRunnerSaved.parametersValues) + assertTrue(newRunnerSaved.parametersValues!!.size == 1) + assertEquals(creationParameterValue, newRunnerSaved.parametersValues!![0]) + + val newParameterValue = + RunnerRunTemplateParameterValue( + parameterId = "param1", value = "10", varType = "still_ignored_var_type") + val updateRunnerSaved = + runnerApiService.updateRunner( + organizationSaved.id!!, + workspaceSaved.id!!, + newRunnerSaved.id!!, + newRunnerSaved.apply { parametersValues = mutableListOf(newParameterValue) }) + + assertNotNull(updateRunnerSaved.parametersValues) + assertTrue(updateRunnerSaved.parametersValues!!.size == 1) + assertEquals("param1", updateRunnerSaved.parametersValues!![0].parameterId) + assertEquals("10", updateRunnerSaved.parametersValues!![0].value) + assertEquals("integer", updateRunnerSaved.parametersValues!![0].varType) + } + @Test fun `test CRUD operations on Runner as Platform Admin`() { every { getCurrentAccountIdentifier(any()) } returns "random_user_with_patform_admin_role" @@ -844,6 +910,16 @@ class RunnerServiceIntegrationTest : CsmRedisTestBase() { mutableListOf( RunTemplateParameterGroup( id = "testParameterGroups", parameters = mutableListOf("param1", "param2"))), + parameters = + mutableListOf( + RunTemplateParameter( + id = "param1", + maxValue = "10", + minValue = "0", + defaultValue = "5", + varType = "integer"), + RunTemplateParameter(id = "param2", varType = "%DATASET%"), + ), runTemplates = mutableListOf( RunTemplate( diff --git a/runner/src/main/kotlin/com/cosmotech/runner/service/RunnerService.kt b/runner/src/main/kotlin/com/cosmotech/runner/service/RunnerService.kt index 1fd6551d0..55fd44543 100644 --- a/runner/src/main/kotlin/com/cosmotech/runner/service/RunnerService.kt +++ b/runner/src/main/kotlin/com/cosmotech/runner/service/RunnerService.kt @@ -189,6 +189,7 @@ class RunnerService( val excludeFields = arrayOf("id", "ownerId", "organizationId", "workspaceId", "creationDate", "security") this.runner.compareToAndMutateIfNeeded(runner, excludedFields = excludeFields) + consolidateParametersVarType() // take newly added datasets and propagate existing ACL on it this.runner.datasetList @@ -236,6 +237,23 @@ class RunnerService( val parameterValueList = this.runner.parametersValues ?: mutableListOf() parameterValueList.addAll(inheritedParameterValues) this.runner.parametersValues = parameterValueList + consolidateParametersVarType() + } + } + + fun consolidateParametersVarType() { + val solutionParameters = + workspace + ?.solution + ?.solutionId + ?.let { solutionApiService.findSolutionById(organization?.id!!, it) } + ?.parameters + + this.runner.parametersValues?.forEach { runnerParam -> + solutionParameters + ?.find { it.id == runnerParam.parameterId } + ?.varType + ?.let { runnerParam.varType = it } } } diff --git a/scenario/src/integrationTest/kotlin/com/cosmotech/scenario/service/ScenarioServiceIntegrationTest.kt b/scenario/src/integrationTest/kotlin/com/cosmotech/scenario/service/ScenarioServiceIntegrationTest.kt index 6af344983..7a7f5b69f 100644 --- a/scenario/src/integrationTest/kotlin/com/cosmotech/scenario/service/ScenarioServiceIntegrationTest.kt +++ b/scenario/src/integrationTest/kotlin/com/cosmotech/scenario/service/ScenarioServiceIntegrationTest.kt @@ -44,9 +44,7 @@ import com.cosmotech.scenario.domain.ScenarioRunTemplateParameterValue import com.cosmotech.scenario.domain.ScenarioSecurity import com.cosmotech.scenario.domain.ScenarioValidationStatus import com.cosmotech.solution.SolutionApiServiceInterface -import com.cosmotech.solution.domain.Solution -import com.cosmotech.solution.domain.SolutionAccessControl -import com.cosmotech.solution.domain.SolutionSecurity +import com.cosmotech.solution.domain.* import com.cosmotech.workspace.WorkspaceApiServiceInterface import com.cosmotech.workspace.azure.IWorkspaceEventHubService import com.cosmotech.workspace.azure.WorkspaceEventHubInfo @@ -263,6 +261,164 @@ class ScenarioServiceIntegrationTest : CsmRedisTestBase() { assertTrue(scenarioListAfterDeleteAll.isEmpty()) } + @Test + fun `test createScenario without parameters`() { + every { getCurrentAuthenticatedRoles(any()) } returns listOf("Platform.Admin") + + val scenarioWithoutParameters = + makeScenario( + organizationSaved.id!!, + workspaceSaved.id!!, + solutionSaved.id!!, + "ScenarioWithoutParameters", + mutableListOf(datasetSaved.id!!)) + + val scenarioWithoutParametersSaved = + scenarioApiService.createScenario( + organizationSaved.id!!, workspaceSaved.id!!, scenarioWithoutParameters) + + assertNotNull(scenarioWithoutParametersSaved.parametersValues) + assertTrue(scenarioWithoutParametersSaved.parametersValues!!.size == 2) + assertEquals("param1", scenarioWithoutParametersSaved.parametersValues!![0].parameterId) + assertEquals("param1VarType", scenarioWithoutParametersSaved.parametersValues!![0].varType) + assertEquals("110", scenarioWithoutParametersSaved.parametersValues!![0].value) + assertEquals("param2", scenarioWithoutParametersSaved.parametersValues!![1].parameterId) + assertEquals("param2VarType", scenarioWithoutParametersSaved.parametersValues!![1].varType) + assertEquals("", scenarioWithoutParametersSaved.parametersValues!![1].value) + } + + @Test + fun `test createScenario with parameters`() { + every { getCurrentAuthenticatedRoles(any()) } returns listOf("Platform.Admin") + + val scenarioWithParameters = + makeScenario( + organizationSaved.id!!, + workspaceSaved.id!!, + solutionSaved.id!!, + "ScenarioWithParameters", + mutableListOf(datasetSaved.id!!), + parametersValues = + mutableListOf( + ScenarioRunTemplateParameterValue( + parameterId = "param1", value = "105", varType = "exclude_read_only_value"), + ScenarioRunTemplateParameterValue( + parameterId = "not_defined_parameter", + value = "105", + varType = "exclude_read_only_value"))) + + val scenarioWithParametersSaved = + scenarioApiService.createScenario( + organizationSaved.id!!, workspaceSaved.id!!, scenarioWithParameters) + + assertNotNull(scenarioWithParametersSaved.parametersValues) + assertTrue(scenarioWithParametersSaved.parametersValues!!.size == 2) + assertEquals("param1", scenarioWithParametersSaved.parametersValues!![0].parameterId) + assertEquals("param1VarType", scenarioWithParametersSaved.parametersValues!![0].varType) + assertEquals("105", scenarioWithParametersSaved.parametersValues!![0].value) + assertEquals("param2", scenarioWithParametersSaved.parametersValues!![1].parameterId) + assertEquals("param2VarType", scenarioWithParametersSaved.parametersValues!![1].varType) + assertEquals("", scenarioWithParametersSaved.parametersValues!![1].value) + } + + @Test + fun `test updateScenario with empty parameters`() { + every { getCurrentAuthenticatedRoles(any()) } returns listOf("Platform.Admin") + + val scenarioWithoutParameters = + makeScenario( + organizationSaved.id!!, + workspaceSaved.id!!, + solutionSaved.id!!, + "ScenarioWithoutParameters", + mutableListOf(datasetSaved.id!!)) + + val scenarioWithoutParametersSaved = + scenarioApiService.createScenario( + organizationSaved.id!!, workspaceSaved.id!!, scenarioWithoutParameters) + + val updatedScenarioWithoutParametersSaved = + scenarioApiService.updateScenario( + organizationSaved.id!!, + workspaceSaved.id!!, + scenarioWithoutParametersSaved.id!!, + scenarioWithoutParametersSaved.apply { + parametersValues = + mutableListOf( + ScenarioRunTemplateParameterValue( + parameterId = "param1", + value = "107", + varType = "exclude_read_only_value"), + ScenarioRunTemplateParameterValue( + parameterId = "not_defined_parameter", + value = "105", + varType = "exclude_read_only_value")) + }) + + assertNotNull(updatedScenarioWithoutParametersSaved.parametersValues) + assertTrue(updatedScenarioWithoutParametersSaved.parametersValues!!.size == 2) + assertEquals("param1", updatedScenarioWithoutParametersSaved.parametersValues!![0].parameterId) + assertEquals( + "param1VarType", updatedScenarioWithoutParametersSaved.parametersValues!![0].varType) + assertEquals("107", updatedScenarioWithoutParametersSaved.parametersValues!![0].value) + assertEquals("param2", updatedScenarioWithoutParametersSaved.parametersValues!![1].parameterId) + assertEquals( + "param2VarType", updatedScenarioWithoutParametersSaved.parametersValues!![1].varType) + assertEquals("", updatedScenarioWithoutParametersSaved.parametersValues!![1].value) + } + + @Test + fun `test updateScenario with non-empty parameters`() { + every { getCurrentAuthenticatedRoles(any()) } returns listOf("Platform.Admin") + + val scenarioWithParameters = + makeScenario( + organizationSaved.id!!, + workspaceSaved.id!!, + solutionSaved.id!!, + "ScenarioWithParameters", + mutableListOf(datasetSaved.id!!), + parametersValues = + mutableListOf( + ScenarioRunTemplateParameterValue( + parameterId = "param1", value = "100", varType = "exclude_read_only_value"), + ScenarioRunTemplateParameterValue( + parameterId = "param2", + value = "this_is_a_value", + varType = "exclude_read_only_value"))) + + val scenarioWithParametersSaved = + scenarioApiService.createScenario( + organizationSaved.id!!, workspaceSaved.id!!, scenarioWithParameters) + + val updatedScenarioWithParametersSaved = + scenarioApiService.updateScenario( + organizationSaved.id!!, + workspaceSaved.id!!, + scenarioWithParametersSaved.id!!, + scenarioWithParametersSaved.apply { + parametersValues = + mutableListOf( + ScenarioRunTemplateParameterValue( + parameterId = "param1", + value = "107", + varType = "exclude_read_only_value"), + ScenarioRunTemplateParameterValue( + parameterId = "not_defined_parameter", + value = "105", + varType = "exclude_read_only_value")) + }) + + assertNotNull(updatedScenarioWithParametersSaved.parametersValues) + assertTrue(updatedScenarioWithParametersSaved.parametersValues!!.size == 2) + assertEquals("param1", updatedScenarioWithParametersSaved.parametersValues!![0].parameterId) + assertEquals("param1VarType", updatedScenarioWithParametersSaved.parametersValues!![0].varType) + assertEquals("107", updatedScenarioWithParametersSaved.parametersValues!![0].value) + assertEquals("param2", updatedScenarioWithParametersSaved.parametersValues!![1].parameterId) + assertEquals("param2VarType", updatedScenarioWithParametersSaved.parametersValues!![1].varType) + assertEquals("", updatedScenarioWithParametersSaved.parametersValues!![1].value) + } + @Test fun `test find All Scenarios with different pagination params`() { val numberOfScenarios = 20 @@ -391,9 +547,6 @@ class ScenarioServiceIntegrationTest : CsmRedisTestBase() { fun `test Scenario Parameter Values as User Admin`() { every { getCurrentAuthenticatedRoles(any()) } returns listOf("Platform.Admin") - logger.info("should assert that the Scenario has no Parameter Values") - assertTrue(scenarioSaved.parametersValues!!.isEmpty()) - logger.info("should add a Parameter Value and assert it has been added") val params = mutableListOf( @@ -988,6 +1141,31 @@ class ScenarioServiceIntegrationTest : CsmRedisTestBase() { name = "My solution", organizationId = organizationId, ownerId = "ownerId", + runTemplates = + mutableListOf( + RunTemplate( + id = "runtemplateTest", + name = "runtemplateTest", + parameterGroups = mutableListOf("RTparametersGroup1"), + )), + parameterGroups = + mutableListOf( + RunTemplateParameterGroup( + id = "RTparametersGroup1", parameters = mutableListOf("param1", "param2"))), + parameters = + mutableListOf( + RunTemplateParameter( + id = "param1", + varType = "param1VarType", + defaultValue = "110", + maxValue = "120", + minValue = "100", + ), + RunTemplateParameter( + id = "param2", + varType = "param2VarType", + ), + ), security = SolutionSecurity( default = ROLE_NONE, @@ -1048,7 +1226,8 @@ class ScenarioServiceIntegrationTest : CsmRedisTestBase() { parentId: String? = null, userName: String = "roleName", role: String = ROLE_USER, - validationStatus: ScenarioValidationStatus = ScenarioValidationStatus.Draft + validationStatus: ScenarioValidationStatus = ScenarioValidationStatus.Draft, + parametersValues: MutableList? = null ): Scenario { return Scenario( id = UUID.randomUUID().toString(), @@ -1056,10 +1235,12 @@ class ScenarioServiceIntegrationTest : CsmRedisTestBase() { organizationId = organizationId, workspaceId = workspaceId, solutionId = solutionId, + runTemplateId = "runtemplateTest", ownerId = "ownerId", datasetList = datasetList, parentId = parentId, validationStatus = validationStatus, + parametersValues = parametersValues, security = ScenarioSecurity( ROLE_NONE, diff --git a/scenario/src/main/kotlin/com/cosmotech/scenario/service/ScenarioServiceImpl.kt b/scenario/src/main/kotlin/com/cosmotech/scenario/service/ScenarioServiceImpl.kt index b7ca459ca..ae5c2f467 100644 --- a/scenario/src/main/kotlin/com/cosmotech/scenario/service/ScenarioServiceImpl.kt +++ b/scenario/src/main/kotlin/com/cosmotech/scenario/service/ScenarioServiceImpl.kt @@ -57,7 +57,6 @@ import com.cosmotech.scenario.domain.ScenarioSecurity import com.cosmotech.scenario.domain.ScenarioValidationStatus import com.cosmotech.scenario.repository.ScenarioRepository import com.cosmotech.solution.SolutionApiServiceInterface -import com.cosmotech.solution.domain.RunTemplate import com.cosmotech.solution.domain.Solution import com.cosmotech.workspace.WorkspaceApiServiceInterface import com.cosmotech.workspace.azure.EventHubRole @@ -155,6 +154,14 @@ internal class ScenarioServiceImpl( var rootId: String? = null val newParametersValuesList = scenario.parametersValues?.toMutableList() ?: mutableListOf() + val runTemplateParametersIds = + solution + ?.parameterGroups + ?.filter { parameterGroup -> + runTemplate?.parameterGroups?.contains(parameterGroup.id) == true + } + ?.flatMap { parameterGroup -> parameterGroup.parameters ?: mutableListOf() } + if (parentId != null) { logger.debug("Applying / Overwriting Dataset list from parent $parentId") val parent = getVerifiedScenario(organizationId, workspaceId, parentId) @@ -165,7 +172,7 @@ internal class ScenarioServiceImpl( } handleScenarioRunTemplateParametersValues( - parentId, solution, runTemplate, parent, scenario, newParametersValuesList) + parentId, runTemplateParametersIds, parent, scenario, newParametersValuesList) } if (workspace.datasetCopy == true) { @@ -189,6 +196,11 @@ internal class ScenarioServiceImpl( .toMutableList() } + val newParametersValues = + runTemplateParametersIds?.let { + consolidateParameters(solution, it, newParametersValuesList) + } + val now = Instant.now().toEpochMilli() val scenarioToSave = scenario.copy( @@ -204,7 +216,7 @@ internal class ScenarioServiceImpl( state = ScenarioJobState.Created, datasetList = datasetList, rootId = rootId, - parametersValues = newParametersValuesList, + parametersValues = newParametersValues, validationStatus = ScenarioValidationStatus.Draft) scenarioToSave.setRbac(csmRbac.initSecurity(scenario.getRbac())) @@ -214,11 +226,49 @@ internal class ScenarioServiceImpl( return scenarioToSave } + private fun consolidateParameters( + solution: Solution, + runTemplateParametersIds: List, + newParametersValuesList: MutableList + ): MutableList { + val result = mutableListOf() + + runTemplateParametersIds.forEach { parameterId -> + val solutionParameter = + solution.parameters?.firstOrNull { runTemplateParameter -> + runTemplateParameter.id == parameterId + } + + if (solutionParameter == null) { + logger.debug( + "Skipping parameter $parameterId, " + + "defined neither in the parent nor in this Scenario nor in the Solution") + } else { + + val currentParameterDefinition = + newParametersValuesList.firstOrNull { newScenarioParameter -> + newScenarioParameter.parameterId == parameterId + } + + if (currentParameterDefinition == null) { + result.add( + ScenarioRunTemplateParameterValue( + parameterId = parameterId, + value = solutionParameter.defaultValue ?: "", + varType = solutionParameter.varType, + )) + } else { + result.add(currentParameterDefinition.apply { varType = solutionParameter.varType }) + } + } + } + return result + } + @Suppress("NestedBlockDepth") private fun handleScenarioRunTemplateParametersValues( parentId: String?, - solution: Solution?, - runTemplate: RunTemplate?, + runTemplateParametersIds: List?, parent: Scenario, scenario: Scenario, newParametersValuesList: MutableList @@ -226,17 +276,9 @@ internal class ScenarioServiceImpl( logger.debug("Copying parameters values from parent $parentId") logger.debug("Getting runTemplate parameters ids") - val runTemplateParametersIds = - solution - ?.parameterGroups - ?.filter { parameterGroup -> - runTemplate?.parameterGroups?.contains(parameterGroup.id) == true - } - ?.flatMap { parameterGroup -> parameterGroup.parameters ?: mutableListOf() } if (!runTemplateParametersIds.isNullOrEmpty()) { val parentParameters = parent.parametersValues?.associate { it.parameterId to it } val scenarioParameters = scenario.parametersValues?.associate { it.parameterId to it } - // TODO Handle default value runTemplateParametersIds.forEach { parameterId -> if (scenarioParameters?.contains(parameterId) != true) { logger.debug( @@ -710,7 +752,27 @@ internal class ScenarioServiceImpl( if (scenario.parametersValues != null && scenario.parametersValues?.toSet() != existingScenario.parametersValues?.toSet()) { - updateScenarioParametersValues(existingScenario, scenario) + + val solution = + workspace.solution.solutionId?.let { + solutionService.getVerifiedSolution(organizationId, it) + } + val runTemplate = + solution?.runTemplates?.find { runTemplate -> runTemplate.id == scenario.runTemplateId } + val runTemplateParametersIds = + solution + ?.parameterGroups + ?.filter { parameterGroup -> + runTemplate?.parameterGroups?.contains(parameterGroup.id) == true + } + ?.flatMap { parameterGroup -> parameterGroup.parameters ?: mutableListOf() } + + val updatedParameters = + consolidateParameters(solution!!, runTemplateParametersIds!!, scenario.parametersValues!!) + + existingScenario.parametersValues = updatedParameters + existingScenario.parametersValues?.forEach { it.isInherited = false } + hasChanged = true } @@ -759,11 +821,6 @@ internal class ScenarioServiceImpl( this, organizationId, workspaceId, scenarioId, scenario.datasetList)) } - private fun updateScenarioParametersValues(existingScenario: Scenario, scenario: Scenario) { - existingScenario.parametersValues = scenario.parametersValues - existingScenario.parametersValues?.forEach { it.isInherited = false } - } - private fun updateScenarioRunTemplate( workspace: Workspace, organizationId: String, diff --git a/scenario/src/test/kotlin/com/cosmotech/scenario/service/ScenarioServiceImplTests.kt b/scenario/src/test/kotlin/com/cosmotech/scenario/service/ScenarioServiceImplTests.kt index 0b3bc2b9d..f0d92adc1 100644 --- a/scenario/src/test/kotlin/com/cosmotech/scenario/service/ScenarioServiceImplTests.kt +++ b/scenario/src/test/kotlin/com/cosmotech/scenario/service/ScenarioServiceImplTests.kt @@ -32,6 +32,7 @@ import com.cosmotech.scenario.domain.ScenarioSecurity import com.cosmotech.scenario.repository.ScenarioRepository import com.cosmotech.solution.SolutionApiServiceInterface import com.cosmotech.solution.domain.RunTemplate +import com.cosmotech.solution.domain.RunTemplateParameter import com.cosmotech.solution.domain.RunTemplateParameterGroup import com.cosmotech.solution.domain.Solution import com.cosmotech.workspace.WorkspaceApiServiceInterface @@ -331,6 +332,22 @@ class ScenarioServiceImplTests { val newScenario = mockScenario() every { scenarioRepository.save(any()) } returns newScenario + every { solution.parameters } returns + mutableListOf( + RunTemplateParameter( + id = "parameter_group_11_parameter1", + defaultValue = "parameter1_group_11_value", + ), + RunTemplateParameter( + id = "parameter_group_11_parameter2", + defaultValue = "parameter2_group_11_value", + ), + RunTemplateParameter( + id = "parameter_group_12_parameter1", + defaultValue = "parameter1_group_12_value", + ), + ) + val scenarioCreated = scenarioServiceImpl.createScenario( ORGANIZATION_ID, @@ -351,7 +368,7 @@ class ScenarioServiceImplTests { val parametersValues = scenarioCreated.parametersValues assertNotNull(parametersValues) assertEquals( - 2, parametersValues.size, "Child Scenario parameters values is not of the right size") + 3, parametersValues.size, "Child Scenario parameters values is not of the right size") val paramGrp21 = parametersValues.filter { it.parameterId == "parameter_group_12_parameter1" } assertEquals(1, paramGrp21.size) assertEquals("parameter_group_12_parameter1_value", paramGrp21[0].value) @@ -429,7 +446,21 @@ class ScenarioServiceImplTests { every { workspace.sendScenarioMetadataToEventHub } returns false val newScenario = mockScenario() every { scenarioRepository.save(any()) } returns newScenario - + every { solution.parameters } returns + mutableListOf( + RunTemplateParameter( + id = "parameter_group_11_parameter1", + defaultValue = "parameter1_group_11_value", + ), + RunTemplateParameter( + id = "parameter_group_11_parameter2", + defaultValue = "parameter2_group_11_value", + ), + RunTemplateParameter( + id = "parameter_group_12_parameter1", + defaultValue = "parameter1_group_12_value", + ), + ) val scenarioCreated = scenarioServiceImpl.createScenario( ORGANIZATION_ID, @@ -449,9 +480,9 @@ class ScenarioServiceImplTests { val parametersValues = scenarioCreated.parametersValues assertNotNull(parametersValues) assertEquals( - 1, parametersValues.size, "Child Scenario parameters values is not of the right size") - assertEquals("parameter_group_12_parameter1", parametersValues[0].parameterId) - assertEquals("parameter_group_12_parameter1_value", parametersValues[0].value) + 3, parametersValues.size, "Child Scenario parameters values is not of the right size") + assertEquals("parameter_group_12_parameter1", parametersValues[2].parameterId) + assertEquals("parameter_group_12_parameter1_value", parametersValues[2].value) assertNull(parametersValues[0].isInherited) } @@ -514,6 +545,21 @@ class ScenarioServiceImplTests { ScenarioRunTemplateParameterValue( parameterId = "parameter_group_11_parameter1", value = "parameter_group_11_parameter1_value_from_parent")) + every { solution.parameters } returns + mutableListOf( + RunTemplateParameter( + id = "parameter_group_11_parameter1", + defaultValue = "parameter1_group_11_value", + ), + RunTemplateParameter( + id = "parameter_group_11_parameter2", + defaultValue = "parameter2_group_11_value", + ), + RunTemplateParameter( + id = "parameter_group_12_parameter1", + defaultValue = "parameter1_group_12_value", + ), + ) every { scenarioServiceImpl.getVerifiedScenario(ORGANIZATION_ID, WORKSPACE_ID, parentScenarioId) @@ -556,7 +602,7 @@ class ScenarioServiceImplTests { val parametersValues = scenarioCreated.parametersValues assertNotNull(parametersValues) assertEquals( - 1, parametersValues.size, "Child Scenario parameters values is not of the right size") + 3, parametersValues.size, "Child Scenario parameters values is not of the right size") assertEquals("parameter_group_11_parameter1", parametersValues[0].parameterId) assertEquals("parameter_group_11_parameter1_value_from_child", parametersValues[0].value) assertNull(parametersValues[0].isInherited)