Bari.Core.Build.Cache.CachedBuilder.Run C# (CSharp) Method

        public ISet<TargetRelativePath> Run(IBuildContext context)
        {
            var buildKey = new BuildKey(wrappedBuilder.BuilderType, wrappedBuilder.Uid);

            cache.LockForBuilder(buildKey);
            try
            {
                if (wrappedBuilder.CanRun())
                {
                    try
                    {
                        var currentFingerprint = wrappedBuilder.Dependencies.Fingerprint;

                        if (cache.Contains(buildKey, currentFingerprint))
                        {
                            log.DebugFormat("Restoring cached build outputs for {0}", buildKey);
                            return cache.Restore(buildKey, targetDir, aggressive, agressiveModeExceptions);
                        }
                        else
                        {
                            log.DebugFormat("Running builder {0}", buildKey);
                            var files = wrappedBuilder.Run(context);

                            log.DebugFormat("Storing build outputs of {0}", buildKey);
                            cache.Store(buildKey, currentFingerprint, files, targetDir);
                            return files;
                        }
                    }
                    catch (Exception ex)
                    {
                        log.ErrorFormat("Failed to run builder {0}: {1}", wrappedBuilder.Uid, ex);

                        // Fallback to any cached value
                        if (SupportsFallback && cache.ContainsAny(buildKey))
                        {
                            log.DebugFormat("Restoring cached build outputs for {0} without fingerprint check", buildKey);
                            return cache.Restore(buildKey, targetDir, aggressive, agressiveModeExceptions);
                        }
                        else
                        {
                            throw;
                        }
                    }
                }
                else
                {
                    // Fallback to any cached value
                    if (cache.ContainsAny(buildKey))
                    {
                        log.DebugFormat("Restoring cached build outputs for {0} without fingerprint check", buildKey);
                        return cache.Restore(buildKey, targetDir, aggressive, agressiveModeExceptions);
                    }
                    else
                    {
                        throw new BuilderCantRunException(wrappedBuilder.Uid);
                    }
                }
            }
            finally
            {
                cache.UnlockForBuilder(buildKey);
            }
        }

        public void RunsBuilderOnlyOnceIfFingerprintRemains()
        {
            // Setting up the test
            var resultSet = new HashSet<TargetRelativePath>
                {
                    new TargetRelativePath(String.Empty, @"a\b\c"), 
                    new TargetRelativePath(String.Empty, @"c\d"), 
                    new TargetRelativePath(String.Empty, @"e")
                };

            var realBuilder = new Mock<IBuilder>();
            var realBuilderDeps = new Mock<IDependencies>();
            var initialFingerprint = new Mock<IDependencyFingerprint>();
            var buildContext = new Mock<IBuildContext>();
            var cache = new Mock<IBuildCache>();
            var targetDir = new TestFileSystemDirectory("target");

            realBuilderDeps.Setup(dep => dep.CreateFingerprint()).Returns(initialFingerprint.Object);
            
            realBuilder.Setup(b => b.Dependencies).Returns(realBuilderDeps.Object);
            realBuilder.Setup(b => b.Uid).Returns("");
            realBuilder.Setup(b => b.Run(buildContext.Object)).Returns(resultSet);

            // Creating the builder
            var cachedBuilder = new CachedBuilder(realBuilder.Object, cache.Object, targetDir);

            cachedBuilder.Dependencies.Should().Be(realBuilderDeps.Object);            
            
            // Running the builder for the first time
            var result1 = cachedBuilder.Run(buildContext.Object);

            // ..verifying
            result1.Should().BeEquivalentTo(resultSet);
            realBuilder.Verify(b => b.Run(buildContext.Object), Times.Once());

            // Modifying cache behavior
            cache.Setup(c => c.Contains(new BuildKey(realBuilder.Object.GetType(), ""), initialFingerprint.Object)).Returns(true);
            cache.Setup(c => c.Restore(new BuildKey(realBuilder.Object.GetType(), ""), targetDir)).Returns(resultSet);

            // Running the builder for the second time
            var result2 = cachedBuilder.Run(buildContext.Object);

            // ..verifying
            result2.Should().BeEquivalentTo(resultSet);
            realBuilder.Verify(b => b.Run(buildContext.Object), Times.Once());
        }