import model.FunctionalTestBucketProvider
import model.Stage
import model.TestCoverage

const val DEFAULT_FUNCTIONAL_TEST_BUCKET_SIZE = 50
const val DEFAULT_LINUX_FUNCTIONAL_TEST_BUCKET_SIZE = 20

class FunctionalTestProject(
    val model: CIBuildModel,
    functionalTestBucketProvider: FunctionalTestBucketProvider,
    val testCoverage: TestCoverage,
    val stage: Stage
) : Project({
    this.id(testCoverage.asId(model))

    }
}

class AutomaticallySplitPerformanceTestProject(model: CIBuildModel, performanceTestBucketProvider: PerformanceTestBucketProvider, stage: Stage, performanceTestCoverage: PerformanceTestCoverage) : PerformanceTestProject(model, performanceTestCoverage, performanceTestBucketProvider.createPerformanceTestsFor(stage, performanceTestCoverage))

package configurations

import jetbrains.buildServer.configs.kotlin.BuildType
import model.Stage

open class BaseGradleBuildType(
    val stage: Stage? = null,
    val failStage: Boolean = true,
    init: BaseGradleBuildType.() -> Unit = {}
) : BuildType() {
    init {
        this.init()
    }

import common.killProcessStep
import common.skipConditionally
import jetbrains.buildServer.configs.kotlin.BuildSteps
import model.CIBuildModel
import model.Stage

class TestPerformanceTest(model: CIBuildModel, stage: Stage) : BaseGradleBuildType(stage, init = {
    val os = Os.LINUX
    val buildTypeThis = this
    val testProject = "smallJavaMultiProject"

    fun BuildSteps.gradleStep(tasks: List<String>) {

import model.CIBuildModel
import model.Stage
import model.StageName
import model.Trigger
import projects.StageProject

class StagePasses(model: CIBuildModel, stage: Stage, prevStage: Stage?, stageProject: StageProject) : BaseGradleBuildType(init = {
    id(stageTriggerId(model, stage))
    uuid = stageTriggerUuid(model, stage)
    name = stage.stageName.stageName + " (Trigger)"
    type = Type.COMPOSITE

    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)

    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

    * **Vuex**.
    * **Vue-router**.
    * **Vuetify** güzel material design kompanentleri için.
    * **TypeScript**.
    * **Nginx** tabanlı Docker sunucusu (Vue-router için yapılandırılmış).
    * Docker ile multi-stage yapı, böylece kodu derlemeniz, kaydetmeniz veya işlemeniz gerekmez.
    * Derleme zamanında Frontend testi (devre dışı bırakılabilir).

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")