class RestResourcesPluginFuncTest extends AbstractRestResourcesFuncTest {

    def "restResources does nothing when there are no tests"() {
        given:
        internalBuild()
        buildFile << """
            apply plugin: 'elasticsearch.java'
            apply plugin: 'elasticsearch.rest-resources'
        """

        String api = "foo.json"
        setupRestResources([api])

        when:

            val buildFiles = projectBuildFiles.get()
            require(paths.size == detailsFiles.size)
            require(paths.size == buildFiles.size)

            for (i in paths.indices) {
                val path = paths[i]
                val detailsFile = detailsFiles[i]
                val buildFile = buildFiles[i]

    def "resolves current version from local build"() {
        given:
        internalBuild()
        localDistroSetup()
        def distroVersion = VersionProperties.getElasticsearch()
        buildFile << """
            apply plugin: 'elasticsearch.internal-distribution-download'

            elasticsearch_distributions {
              test_distro {
                  version = "$distroVersion"

        "7.10.1"       | "bugfix"   | "assemble"
    }

    def "builds distribution from branches via archives extractedAssemble"() {
        given:
        buildFile.text = ""
        internalBuild(buildFile, "7.12.1", "7.13.0", "7.14.0")
        buildFile << """
            apply plugin: 'elasticsearch.internal-distribution-bwc-setup'
        """
        when:

                  id 'elasticsearch.internal-distribution-archive-check'
                }"""
        }
        file("SomeFile.txt") << """
            some dummy txt file
        """

        buildFile << """
            allprojects {
                apply plugin:'base'
                ext.elasticLicenseUrl = "http://foo.bar"
            }
            tasks.register("buildDarwinTar", Tar) {

import org.gradle.testkit.runner.TaskOutcome

class LicenseHeadersPrecommitPluginFuncTest extends AbstractGradleFuncTest {

    def "detects invalid files with invalid license header"() {
        given:
        buildFile << """
        plugins {
            id 'java'
            id 'elasticsearch.internal-licenseheaders'
        }
        """
        dualLicensedFile()
        unknownSourceFile()
        unapprovedSourceFile()

import org.gradle.testkit.runner.TaskOutcome
import spock.lang.Unroll

class InternalDistributionArchiveSetupPluginFuncTest extends AbstractGradleFuncTest {

    def setup() {
        buildFile << """
        import org.elasticsearch.gradle.internal.SymbolicLinkPreservingTar

        plugins {
            id 'elasticsearch.internal-distribution-archive-setup'
        }
        """

        given:
        def mockRepoUrl = urlPath(jdkVendor, jdkVersion, platform, arch);
        def mockedContent = filebytes(jdkVendor, platform)
        buildFile.text = """
            plugins {
             id 'elasticsearch.jdk-download'
            }

            jdks {
              myJdk {
                vendor = '$jdkVendor'
                version = '$jdkVersion'

        }

        when:
        result = gradleRunner(transformTask).build()

        then:
        result.task(transformTask).outcome == TaskOutcome.UP_TO_DATE

        when:
        buildFile.write(buildFile.text.replace("blah", "baz"))
        result = gradleRunner(transformTask).build()

        then:
        result.task(transformTask).outcome == TaskOutcome.SUCCESS
    }

import org.gradle.testkit.runner.TaskOutcome

class InternalYamlRestTestPluginFuncTest extends AbstractRestResourcesFuncTest {

    def "yamlRestTest does nothing when there are no tests"() {
        given:
        buildFile << """
        plugins {
          id 'elasticsearch.internal-yaml-rest-test'
        }
        """

        when:
        def result = gradleRunner("yamlRestTest").build()

        then: