Try<Execution> execution = Try.successful(Execution.skipped(UP_TO_DATE, work));
        return new UpToDateResult(
            previousExecutionState.getOriginMetadata().getExecutionTime(),
            execution,
            executionOutputState,
            ImmutableList.of(),
            previousExecutionState.getOriginMetadata()
        );
    }

    }

    // TODO: Move this logic in a step around IdentityCacheStep
    private <T> void emitExecuteDeferredProgressDetails(UnitOfWork work, Identity identity, IdentityCacheResult<T> cacheResult) {
        cacheResult.getOriginMetadata().ifPresent(originMetadata ->
            progressEventEmitter.emitNowIfCurrent(new DefaultExecuteDeferredWorkProgressDetails(
                work.getBuildOperationWorkType().orElse(null),
                identity,

        then:
        1 * immutableWorkspaceMetadataStore.loadWorkspaceMetadata(immutableWorkspace) >> Stub(ImmutableWorkspaceMetadata) {
            getOriginMetadata() >> delegateOriginMetadata
            getOutputPropertyHashes() >> ImmutableListMultimap.of("output", outputFileSnapshot.hash)
        }
        0 * _
    }

        then:
        1 * delegateResult.afterExecutionOutputState >> Optional.of(Mock(AfterExecutionState) {
            _ * getOutputFilesProducedByWork() >> this.outputFilesProducedByWork
            _ * getOriginMetadata() >> originMetadata
        })

        _ * context.cachingState >> CachingState.enabled(new DefaultBuildCacheKey(cacheKey), beforeExecutionState)
        _ * delegateResult.execution >> Try.successful(Mock(Execution))

            return afterExecutionOutputState.getOutputFilesProducedByWork();
        }

        @Override
        public OriginMetadata getOriginMetadata() {
            return afterExecutionOutputState.getOriginMetadata();
        }

        @Override
        public boolean isReused() {
            return afterExecutionOutputState.isReused();
        }
    }

    }

    @Override
    public ImmutableSortedMap<String, FileSystemSnapshot> getOutputFilesProducedByWork() {
        return outputFilesProducedByWork;
    }

    @Override
    public OriginMetadata getOriginMetadata() {
        return originMetadata;
    }

    @Override
    public boolean isSuccessful() {
        return successful;
    }

    @Override
    public boolean isReused() {
        return true;

    }

    @Override
    public void store(String key, AfterExecutionState executionState) {
        store.put(key, new DefaultPreviousExecutionState(
            executionState.getOriginMetadata(),
            executionState.getCacheKey(),
            executionState.getImplementation(),
            executionState.getAdditionalImplementations(),
            executionState.getInputProperties(),

    }

    @Override
    public void store(String key, AfterExecutionState executionState) {
        executionHistory.put(key, new DefaultPreviousExecutionState(
            executionState.getOriginMetadata(),
            executionState.getCacheKey(),
            executionState.getImplementation(),
            executionState.getAdditionalImplementations(),
            executionState.getInputProperties(),

                            work.getDisplayName(), cacheKey.getHashCode());
                    }
                    cleanLocalState(context.getWorkspace(), work);
                    OriginMetadata originMetadata = cacheHit.getOriginMetadata();
                    Try<Execution> execution = Try.successful(Execution.skipped(FROM_CACHE, work));

        _ * context.rebuildReasons >> ImmutableList.of()
        _ * context.previousExecutionState >> Optional.of(Stub(PreviousExecutionState) {
            getOutputFilesProducedByWork() >> ImmutableSortedMap.of()
            getOriginMetadata() >> delegateOriginMetadata
        })
        0 * _
    }

    def "executes when outputs are not up to date"() {
        def delegateOutcome = Try.successful(Mock(Execution))