Config architecture and Git integration testing (#3)

* quick test

* started working on YAML file

* adding configuration structure

* adding some testing tools

* verified that GitDiff works as expected for adding files

* verified that Diff detection works in all cases

Author: Aaronontheweb

src/Incrementalist.Cmd/Program.cs

@@ -5,21 +5,14 @@
 using System.Linq;
 using System.Runtime.InteropServices;
 using System.Threading.Tasks;
-using Incrementalist.FileSystem;
 using Incrementalist.Git;
+using Incrementalist.ProjectSystem;
 using LibGit2Sharp;
 using Microsoft.Build.Locator;
 using Microsoft.CodeAnalysis.MSBuild;
 
 namespace Incrementalist.Cmd
 {
-    enum FileType
-    {
-        Code,
-        Project,
-        Solution,
-        Other
-    }
 
     class Program
     {
@@ -60,11 +53,11 @@ static async Task<int> Main(string[] args)
             //if (insideRepo)
             //{
             var repoFolder = Repository.Discover(Directory.GetCurrentDirectory());
-            var repository = new Repository(repoFolder);
+            var repository = new Repository(repoFolder);            
             Console.WriteLine("Repo base is located in {0}", repoFolder);
             var workingFolder = Directory.GetParent(repoFolder).Parent;
 
-            var affectedFiles = DiffHelper.ChangedFiles(repository, "master").Select(x => Path.GetFullPath(x, workingFolder.FullName)).ToList();
+            var affectedFiles = DiffHelper.ChangedFiles(repository, "dev").Select(x => Path.GetFullPath(x, workingFolder.FullName)).ToList();
             foreach (var file in affectedFiles)
                 Console.WriteLine("Modified file: {0}", file);
             //}

src/Incrementalist.Tests/Git/GitDiffDetectionSpecs.cs

@@ -0,0 +1,78 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Linq;
+using System.Text;
+using FluentAssertions;
+using Incrementalist.Git;
+using Incrementalist.Tests.Helpers;
+using Xunit;
+
+namespace Incrementalist.Tests.Git
+{
+    public class GitDiffDetectionSpecs : IDisposable
+    {
+        public DisposableRepository Repository { get; }
+
+        public GitDiffDetectionSpecs()
+        {
+            Repository = new DisposableRepository();
+        }
+
+        [Fact(DisplayName = "Should detect files that have been added to git repo")]
+        public void Should_detect_added_files_to_bare_Repo()
+        {
+            Repository.CreateBranch("foo").CheckoutBranch("foo").WriteFile("fuber.txt", "fuber").Commit("Fuberized file");
+            var diffedFiles = DiffHelper.ChangedFiles(Repository.Repository, "master").ToList();
+            diffedFiles.Count.Should().Be(1);
+            var file = diffedFiles[0];
+            Path.GetFileName(file).Should().Be("fuber.txt");
+        }
+
+        [Fact(DisplayName = "Should detect files that have been modified in existing repo")]
+        public void Should_detect_changes_to_existing_files_in_Repo()
+        {
+            Repository.WriteFile("fuber.txt", "fuber")
+                .Commit("Fuberized file")
+                .CreateBranch("foo")
+                .CheckoutBranch("foo")
+                .WriteFile("fuber.txt", "fuber2")
+                .Commit("Updated fuberized file");
+
+            var diffedFiles = DiffHelper.ChangedFiles(Repository.Repository, "master").ToList();
+            diffedFiles.Count.Should().Be(1);
+            var file = diffedFiles[0];
+            Path.GetFileName(file).Should().Be("fuber.txt");
+        }
+
+        [Fact(DisplayName = "Should detect files that have been deleted in existing repo")]
+        public void Should_detect_delete_of_existing_file_in_Repo()
+        {
+            Repository.WriteFile("fuber.txt", "fuber")
+                .Commit("Fuberized file")
+                .CreateBranch("foo")
+                .CheckoutBranch("foo")
+                .DeleteFile("fuber.txt")
+                .Commit("Delete fuberized file");
+
+            var diffedFiles = DiffHelper.ChangedFiles(Repository.Repository, "master").ToList();
+            diffedFiles.Count.Should().Be(1);
+            var file = diffedFiles[0];
+            Path.GetFileName(file).Should().Be("fuber.txt");
+        }
+
+        [Fact(DisplayName = "Should not detect any changes when none are present")]
+        public void Should_not_detect_any_changes_when_none_present()
+        {
+            Repository.CreateBranch("foo").CheckoutBranch("foo");
+
+            var diffedFiles = DiffHelper.ChangedFiles(Repository.Repository, "master").ToList();
+            diffedFiles.Count.Should().Be(0);
+        }
+
+        public void Dispose()
+        {
+            Repository?.Dispose();
+        }
+    }
+}

src/Incrementalist.Tests/Helpers/DisposableRepository.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using System.Threading;
+using LibGit2Sharp;
+
+namespace Incrementalist.Tests.Helpers
+{
+    public class DisposableRepository : IDisposable
+    {
+        /// <summary>
+        /// Since it might take a few tries to delete the Git repository.
+        /// </summary>
+        private const int MaxDeleteAttempts = 5;
+
+        /// <summary>
+        /// Needed to create repositories in random, temporary directories.
+        /// </summary>
+        /// <returns>The path to a temporary, random directory.</returns>
+        public static string CreateTempDirectory()
+        {
+            var dirPath = System.IO.Path.Combine(System.IO.Path.GetTempPath(), Path.GetFileNameWithoutExtension(System.IO.Path.GetRandomFileName()));
+            Directory.CreateDirectory(dirPath);
+            return dirPath;
+        }
+
+        public DisposableRepository() : this(CreateTempDirectory()) { }
+
+        public DisposableRepository(string basePath)
+        {
+            BasePath = basePath;
+            Init();
+        }
+
+        private void Init()
+        {
+            var repoPath = Repository.Init(BasePath);
+            Repository = new Repository(repoPath);
+            var sig = CreateSignature();
+            Repository.Commit("First", sig, sig);
+            //Repository.CreateBranch("master"); // setup the master branch initially
+        }
+
+        public string BasePath { get; }
+
+        public Repository Repository { get; private set; }
+
+        /// <summary>
+        /// Create a new branch inside this repository.
+        /// </summary>
+        /// <param name="branchName">The name of the branch to be created.</param>
+        /// <returns>The current <see cref="DisposableRepository"/>.</returns>
+        public DisposableRepository CreateBranch(string branchName)
+        {
+            Repository.CreateBranch(branchName);
+            return this;
+        }
+
+        /// <summary>
+        /// Checks out the specified branch, assuming it exists.
+        /// </summary>
+        /// <param name="branchName">The name of the branch to be checked out.</param>
+        /// <returns>The current <see cref="DisposableRepository"/>.</returns>
+        public DisposableRepository CheckoutBranch(string branchName)
+        {
+            var branch = Repository.Branches[branchName];
+            var currentBranch = Commands.Checkout(Repository, branch);
+            return this;
+        }
+
+        /// <summary>
+        /// Add a new file to the repository.
+        /// </summary>
+        /// <param name="fileName">The name of the file to add or overwrite.</param>
+        /// <param name="fileText">The content of the file.</param>
+        /// <returns>The current <see cref="DisposableRepository"/>.</returns>
+        public DisposableRepository WriteFile(string fileName, string fileText)
+        {
+            var filePath = Path.Combine(BasePath, fileName);
+            File.WriteAllText(filePath, fileText);
+            Commands.Stage(Repository, filePath);
+            return this;
+        }
+
+        /// <summary>
+        /// Delete an existing file from the repository.
+        /// </summary>
+        /// <param name="fileName">The name of the file to delete.</param>
+        /// <returns>The current <see cref="DisposableRepository"/>.</returns>
+        public DisposableRepository DeleteFile(string fileName)
+        {
+            var filePath = Path.Combine(BasePath, fileName);
+            File.Delete(fileName);
+            Commands.Remove(Repository, filePath);
+            return this;
+        }
+
+        /// <summary>
+        /// Create a new commit inside the <see cref="Repository"/>.
+        /// </summary>
+        /// <param name="commitMessage">The commit message.</param>
+        /// <param name="author">Optional. The signature of the author performing the commit.</param>
+        /// <returns>The current <see cref="DisposableRepository"/>.</returns>
+        public DisposableRepository Commit(string commitMessage, Signature author = null)
+        {
+            var committer = author ?? CreateSignature();
+            Repository.Commit(commitMessage, committer, committer);
+            return this;
+        }
+
+        public static Signature CreateSignature(string name = null, string email = null)
+        {
+            return new Signature(name ?? "Fuber", email ?? "fuber@petabridge.com", DateTimeOffset.UtcNow);
+        }
+
+        public void Dispose()
+        {
+            Repository?.Dispose();
+            for (var attempt = 1; attempt <= MaxDeleteAttempts; attempt++)
+            {
+                try
+                {
+                    Directory.Delete(BasePath, true);
+                    return;
+                }
+                catch (Exception ex)
+                {
+                    if (attempt < MaxDeleteAttempts)
+                    {
+                        // some exponential backoff here
+                        Thread.Sleep(100 + (int)Math.Pow(10, attempt - 1));
+                    }
+                }
+            }
+           
+        }
+    }
+}

src/Incrementalist.Tests/Incrementalist.Tests.csproj

@@ -6,6 +6,7 @@
   </PropertyGroup>
 
   <ItemGroup>
+    <PackageReference Include="FluentAssertions" Version="5.6.0" />
     <PackageReference Include="Microsoft.NET.Test.Sdk" Version="$(TestSdkVersion)" />
     <PackageReference Include="xunit" Version="$(XunitVersion)" />
     <PackageReference Include="xunit.runner.visualstudio" Version="$(XunitVersion)" />

src/Incrementalist.Tests/UnitTest1.cs

@@ -0,0 +1,47 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+
+namespace Incrementalist
+{
+    /// <summary>
+    /// The types of files that can be detected automatically by Roslyn.
+    /// </summary>
+    public enum FileType
+    {
+        Code,
+        Project,
+        Solution,
+        Script,
+        Other
+    }
+
+
+    /// <summary>
+    /// Used to document a file that was affected by the current commit.
+    /// </summary>
+    public sealed class AffectedFile
+    {
+        public AffectedFile(string path, FileType fileType, string project)
+        {
+            Path = path;
+            FileType = fileType;
+            Project = project;
+        }
+
+        /// <summary>
+        /// The absolute path to the file.
+        /// </summary>
+        public string Path { get; }
+
+        /// <summary>
+        /// The type of file detected in the diff.
+        /// </summary>
+        public FileType FileType { get; }
+
+        /// <summary>
+        /// The name of the affected project.
+        /// </summary>
+        public string Project { get; }
+    }
+}

src/Incrementalist/AffectedFile.cs

@@ -0,0 +1,37 @@
+namespace Incrementalist
+{
+    /// <summary>
+    /// Used to define a build step, which may or may not be used
+    /// depending on whether or not one of the affected projects requires it.
+    /// </summary>
+    public sealed class BuildStep
+    {
+        public BuildStep(string stepName, string commandText, IBuildStepApplicator applicator)
+        {
+            StepName = stepName;
+            CommandText = commandText;
+            Applicator = applicator;
+        }
+
+        /// <summary>
+        /// The name of this build step.
+        /// </summary>
+        public string StepName { get; }
+
+        /// <summary>
+        /// The text to emit when this build step is used.
+        ///
+        /// Some supported format strings:
+        ///  - "{fileName}" will swap in the name of the file, with the extension
+        ///  - "{filePath}" will swap in the absolute path of the file
+        ///  - "{projectName}" will swap in the name of the project, without the extension
+        ///  - "{projectPath}" will swap in the full path of the project including the extension
+        /// </summary>
+        public string CommandText { get; }
+
+        /// <summary>
+        /// The applicator used to evaluate whether or not this build step applies to a particular path.
+        /// </summary>
+        public IBuildStepApplicator Applicator { get; }
+    }
+}

src/Incrementalist/BuildStep.cs

@@ -12,9 +12,10 @@ namespace Incrementalist.Git
     /// </summary>
     public static class DiffHelper
     {
-        public static IEnumerable<string> ChangedFiles(Repository repo, string targetBranch)
+        public static IEnumerable<string> ChangedFiles(Repository repo, string targetBranch, string workingDirectory = null)
         {
-            return repo.Diff.Compare<TreeChanges>(repo.Branches[targetBranch].Tip.Tree, DiffTargets.Index).Select(x => x.Path);
+            var finalDir = workingDirectory ?? Directory.GetCurrentDirectory();
+            return repo.Diff.Compare<TreeChanges>(repo.Branches[targetBranch].Tip.Tree, DiffTargets.Index).Select(x => Path.GetFullPath(x.Path));
         }
     }
 }