override fun createFunctionalTestsFor(stage: Stage, testCoverage: TestCoverage): List<FunctionalTest> {
        return when {
            testCoverage.testType == TestType.quickFeedbackCrossVersion -> quickCrossVersionTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)
            testCoverage.testType == TestType.allVersionsCrossVersion -> allCrossVersionTestBucketProvider.createFunctionalTestsFor(stage, testCoverage)

        val steps = nightlySnapshot.steps.items
        assertEquals(3, steps.size)

        val expectedGradleParams = """-PcommitId=%dep.Gradle_Release_Check_Stage_ReadyforNightly_Trigger.build.vcs.number%  "-PgitUserName=bot-teamcity" "-PgitUserEmail=******@****.***" $pluginPortalUrlOverride %additional.gradle.parameters%"""

        val checkReady = gradleStep(steps, 0)

    override
    fun createPerformanceTestsFor(model: CIBuildModel, stage: Stage, performanceTestCoverage: PerformanceTestCoverage, bucketIndex: Int): PerformanceTest = createPerformanceTest(
        model,
        performanceTestCoverage,
        stage,
        bucketIndex,
        "Performance tests for $testProject",
        mapOf(testProject to scenarios)
    )
}

    val testCoverage: TestCoverage,
    stage: Stage,
    parallelizationMethod: ParallelizationMethod = ParallelizationMethod.None,
    subprojects: List<String> = listOf(),
    extraParameters: String = "",
    maxParallelForks: String = "%maxParallelForks%",
    extraBuildSteps: BuildSteps.() -> Unit = {},
    preBuildSteps: BuildSteps.() -> Unit = {}
) : BaseGradleBuildType(stage = stage, init = {
    this.name = name

import common.JvmCategory
import common.requiresNotEc2Agent
import common.toCapitalized
import model.CIBuildModel
import model.Stage

class SmokeTests(model: CIBuildModel, stage: Stage, testJava: JvmCategory, id: String, task: String = "smokeTest", splitNumber: Int = 1) : BaseGradleBuildType(stage = stage, init = {
    id("${model.projectId}_SmokeTest_$id")

When using Poetry, it would make sense to use **Docker multi-stage builds** because you don't really need to have Poetry and its dependencies installed in the final container image, you **only need** to have the generated `requirements.txt` file to install your project dependencies.

Then in the next (and final) stage you would build the image more or less in the same way as described before.

 * limitations under the License.
 */

package configurations

import common.requiresNotEc2Agent
import model.CIBuildModel
import model.Stage

class SmokeIdeTests(model: CIBuildModel, stage: Stage) : BaseGradleBuildType(stage = stage, init = {
    id(buildTypeId(model))
    name = "Smoke Ide Tests"
    description = "Tests against IDE sync process"

    features {

                gradleParams = promotionBuildParameters(RelativeId("Check_Stage_ReadyforNightly_Trigger"), "-PconfirmationCode=%confirmationCode%", "%gitUserName%", "%gitUserEmail%")
                param("org.jfrog.artifactory.selectedDeployableServer.defaultModuleVersionConfiguration", "GLOBAL")
            }
        }

        dependencies {
            snapshot(RelativeId("Check_Stage_ReadyforNightly_Trigger")) {
            }
        }
    }

import jetbrains.buildServer.configs.kotlin.BuildStep
import jetbrains.buildServer.configs.kotlin.buildSteps.script
import model.CIBuildModel
import model.Stage
import model.StageName

class FlakyTestQuarantine(model: CIBuildModel, stage: Stage, os: Os, arch: Arch = Arch.AMD64) : BaseGradleBuildType(stage = stage, init = {
    id("${model.projectId}_FlakyQuarantine_${os.asName()}_${arch.asName()}")
    name = "Flaky Test Quarantine - ${os.asName()} ${arch.asName()}"

            name: 'ITS_BRANCH' )
  }
  stages {
    stage("Build Maven Core") {
      steps {
        withEnv(["JAVA_HOME=${ tool "JDK 1.8 (latest)" }", "PATH+MAVEN=${tool 'Maven 3.6.3'}/bin:${env.JAVA_HOME}/bin"]) {
            sh "mvn -Drat.skip=true -T2 -B -V install -PversionlessMavenDist -Dmaven.repo.local=${env.WORKSPACE}/repo"
        }
      }
    }
    stage( "Run Maven Integration Testing" ) {
      steps {