import org.junit.Test


class TaskContainerExtensionsTest {

    @Test
    fun `can create tasks with injected constructor arguments`() {

        val task = mock<DefaultTask>()
        val tasks = mock<TaskContainer> {
            on { create("my", DefaultTask::class.java, "foo", "bar") } doReturn task
        }

        tasks.create<DefaultTask>("my", "foo", "bar")

        1 * action3.get() >> "three"
        0 * _
    }

    def "queues supplied actions to run in parallel"() {
        given:
        def action1 = Mock(Supplier)
        def action2 = Mock(Supplier)
        def action3 = Mock(Supplier)
        def queue = Mock(BuildOperationQueue)

        when:
        def result = runner.run([action1, action2, action3])

        then:
        result == ["one", "two", "three"]

        given:
        def ancestryTracker = Mock(BuildOperationAncestryTracker)
        def testExecutionRequest = Mock(TestExecutionRequestAction)
        TestExecutionResultEvaluator evaluator = new TestExecutionResultEvaluator(ancestryTracker, testExecutionRequest)
        1 * testExecutionRequest.getTaskSpecs() >> []

        def testDescriptorInternal = Mock(TestDescriptorInternal)

    def consumerProvidedVariantFinder = Mock(ConsumerProvidedVariantFinder)
    def transformedVariantFactory = Mock(TransformedVariantFactory)
    def dependenciesResolverFactory = Mock(TransformUpstreamDependenciesResolverFactory)
    def attributeMatcher = Mock(AttributeMatcher)
    def attributesSchema = Mock(AttributesSchemaInternal) {
        withProducer(_) >> attributeMatcher

    final ToolingImplementationLoader target = Mock()
    final ProgressLoggerFactory loggerFactory = Mock()
    final InternalBuildProgressListener progressListener = Mock()
    final ConnectionParameters params = DefaultConnectionParameters.builder().build()
    final BuildCancellationToken cancellationToken = Mock()

import spock.lang.Specification

import java.util.concurrent.Callable
import java.util.function.Consumer

class UnpackingVisitorTest extends Specification {
    def context = Mock(Consumer)
    def resolver = Mock(PathToFileResolver)
    def patternSetFactory = Mock(Factory)
    def visitor = new UnpackingVisitor(context, resolver, TestFiles.taskDependencyFactory(), patternSetFactory)

    def "resolves null"() {
        when:

metadata:
  name: mock
  labels:
    app: mock
spec:
  ports:
  - port: 99
    protocol: TCP
    targetPort: 9949
  selector:
    app: mock
---
apiVersion: v1
kind: ReplicationController
metadata:
  name: mock
spec:
  replicas: 1
  selector:
    app: mock
  template:
    metadata:
      labels:
        app: mock
    spec:
      containers:
      - name: mock-container

        int cpt = dynCount++
        Mock(ResolvableSelectorState) {
            getVersionConstraint() >> Mock(ResolvedVersionConstraint) {
                isDynamic() >> true
            }
            toString() >> "dynamic selector $cpt"
        }
    }

    ResolvableSelectorState latestSelector() {
        Mock(ResolvableSelectorState) {
            getVersionConstraint() >> Mock(ResolvedVersionConstraint) {

        1 * lock.close()
        0 * _
    }

    def "notifies handler when lock is acquired and released"() {
        def action = Mock(Supplier)
        def onOpen = Mock(Consumer)
        def onClose = Mock(Consumer)
        def lock = Mock(FileLock)
        def signal = Mock(FileLockReleasedSignal)
        Consumer contendedAction

    FileResolver fileResolver = Mock(FileResolver)
    ScriptPluginFactory scriptPluginFactory = Mock(ScriptPluginFactory)
    ScriptHandlerFactory scriptHandlerFactory = Mock(ScriptHandlerFactory)
    ScriptHandler settingsScriptHandler = Mock(ScriptHandler)
    DefaultPluginManager pluginManager = Mock(DefaultPluginManager)
    FeatureFlags previews = Mock(FeatureFlags)
    DefaultSettings settings