return Stub(BuildResult) {
                getModel() >> actionResult
            }
        }
        1 * action.execute({ it instanceof BuildController }) >> 'result'
    }

    def "adapts build action failure"() {
        def action = Mock(BuildAction)
        def parameters = Stub(ConsumerOperationParameters)
        def failure = new RuntimeException()

abstract class AbstractTarBuildCacheEntryPackerSpec extends Specification {
    @Rule
    TestNameTestDirectoryProvider temporaryFolder = new TestNameTestDirectoryProvider(getClass())
    def readOrigin = Stub(OriginReader)
    def writeOrigin = Stub(OriginWriter)

    def filePermissionAccess = createFilePermissionAccess()
    def deleter = createDeleter()
    def fileSystemSupport = new DefaultTarPackerFileSystemSupport(deleter)

        }
        getConvention() >> Stub(Convention) {
            findPlugin(_) >> null
        }
        getExtensions() >> Stub(ExtensionContainerInternal) {
            getByType(JavaPluginExtension) >> Mock(JavaPluginExtension)
        }
        getTasks() >> tasks
        getConfigurations() >> configurations
    }

    @Subject

import spock.lang.Subject

class TwoStageModuleVersionsCacheTest extends Specification {
    def timeProvider = Stub(BuildCommencedTimeProvider)
    def readCache = Mock(AbstractModuleVersionsCache)
    def writeCache = Mock(AbstractModuleVersionsCache)
    def key = Stub(ModuleAtRepositoryKey)
    def entry = Stub(ModuleVersionsCacheEntry)

    @Subject

        expect:
        def artifact = new DefaultModuleComponentArtifactMetadata(Stub(ModuleComponentIdentifier), ivyArtifact("name", "type", "ext", 'classifier'))
        artifact.toString() == artifact.id.toString()
    }

    def "extracts attributes from provided artifact instance"() {
        expect:
        def artifact = new DefaultModuleComponentArtifactMetadata(Stub(ModuleComponentIdentifier), ivyArtifact("name", "type", "ext", 'classifier'))

        descriptor.metaData == metaData
        descriptor.authoritative
        descriptor.hasResult()
    }

    def "can replace meta-data when resolved"() {
        def metaData = Stub(ModuleComponentResolveMetadata)
        def metaData2 = Stub(ModuleComponentResolveMetadata)

        descriptor.resolved(metaData)

        when:
        descriptor.setMetadata(metaData2)

        then:

        _ * startEvent.getDescriptor() >> projectConfigurationDescriptor

        def binaryPluginApplicationResult = Stub(InternalPluginApplicationResult)
        _ * binaryPluginApplicationResult.getPlugin() >> Stub(InternalBinaryPluginIdentifier) {
            getClassName() >> 'com.acme.SomePlugin'
            getPluginId() >> 'com.acme.some'
        }

        mapped.present
        mapped.get() == "[123]"
    }

    def "can chain mapped providers"() {
        def transformer1 = Stub(Transformer)
        transformer1.transform(_) >> { String s -> "[$s]" as String }
        def transformer2 = Stub(Transformer)
        transformer2.transform(_) >> { String s -> "-$s-" as String }

        expect:

    def listener = new TransformingAsyncArtifactListener([new BoundTransformStep(transformStep, Stub(TransformUpstreamDependencies))], targetAttributes, ImmutableCapabilities.EMPTY, result)
    def file = new File("foo")
    def artifactFile = new File("foo-artifact")
    def artifactId = Stub(ComponentArtifactIdentifier)
    def source = Stub(CalculatedValue) {
        isFinalized() >> true
        getValue() >> Try.successful(file)
    }

        def cachedMetaData = Stub(ExternalResourceMetaData) {
            getEtag() >> etag
            getContentLength() >> 42
        }
        def remoteMetaData = Stub(ExternalResourceMetaData) {
            getEtag() >> etag
            getSha1() >> sha1
        }
        def remoteResource = Stub(ExternalResource) {
            getMetaData() >> remoteMetaData
        }