Added extensions and fixtures for testing purposes

Author: GeertvanHorrik

src/GitTools.Core/Constants.cs

@@ -1,4 +1,30 @@
 namespace GitTools
 {
-    // TODO: Constants go here
+    using System;
+    using LibGit2Sharp;
+
+    public static class TestValues
+    {
+        private static DateTimeOffset _simulatedTime = DateTimeOffset.Now.AddHours(-1);
+
+        public static DateTimeOffset Now
+        {
+            get
+            {
+                _simulatedTime = _simulatedTime.AddMinutes(1);
+                return _simulatedTime;
+            }
+        }
+
+        public static Signature SignatureNow()
+        {
+            var dateTimeOffset = Now;
+            return Signature(dateTimeOffset);
+        }
+
+        public static Signature Signature(DateTimeOffset dateTimeOffset)
+        {
+            return new Signature("A. U. Thor", "[email protected]", dateTimeOffset);
+        }
+    }
 }

src/GitTools.Core/Extensions/StringBuilderExtensions.cs

@@ -0,0 +1,14 @@
+namespace GitTools
+{
+    using System.Text;
+
+    public static class StringBuilderExtensions
+    {
+        //[StringFormatMethod("format")]
+        public static void AppendLineFormat(this StringBuilder stringBuilder, string format, params object[] args)
+        {
+            stringBuilder.AppendFormat(format, args);
+            stringBuilder.AppendLine();
+        }
+    }
+}

src/GitTools.Core/GitTools.Core.csproj

@@ -68,17 +68,23 @@
     <Compile Include="Exceptions\GitToolsException.cs" />
     <Compile Include="Extensions\IntExtensions.cs" />
     <Compile Include="Extensions\LibGitExtensions.cs" />
+    <Compile Include="Extensions\StringBuilderExtensions.cs" />
     <Compile Include="Extensions\StringExtensions.cs" />
     <Compile Include="Git\GitDirFinder.cs" />
     <Compile Include="Git\GitPreparer.cs" />
     <Compile Include="Git\Interfaces\IRepositoryPreparer.cs" />
     <Compile Include="Git\RepositoryLoader.cs" />
     <Compile Include="Helpers\DeleteHelper.cs" />
     <Compile Include="Helpers\GitHelper.cs" />
+    <Compile Include="Helpers\ProcessHelper.cs" />
     <Compile Include="IO\TemporaryFilesContext.cs" />
     <Compile Include="Logging\Extensions\LogExtensions.cs" />
     <Compile Include="ModuleInitializer.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Testing\Extensions\GitTestExtensions.cs" />
+    <Compile Include="Testing\Fixtures\EmptyRepositoryFixture.cs" />
+    <Compile Include="Testing\Fixtures\RemoteRepositoryFixture.cs" />
+    <Compile Include="Testing\Fixtures\RepositoryFixtureBase.cs" />
   </ItemGroup>
   <ItemGroup>
     <EmbeddedResource Include="..\..\lib\LibGit2Sharp.0.21.0.176\lib\net40\NativeBinaries\amd64\git2-e0902fb.dll">

src/GitTools.Core/Helpers/ProcessHelper.cs

@@ -0,0 +1,144 @@
+namespace GitTools
+{
+    using System;
+    using System.Collections.Generic;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Runtime.InteropServices;
+    using System.Threading;
+
+    public static class ProcessHelper
+    {
+        private static volatile object _lockObject = new object();
+
+        // http://social.msdn.microsoft.com/Forums/en/netfxbcl/thread/f6069441-4ab1-4299-ad6a-b8bb9ed36be3
+        public static Process Start(ProcessStartInfo startInfo)
+        {
+            Process process;
+
+            lock (_lockObject)
+            {
+                using (new ChangeErrorMode(ErrorModes.FailCriticalErrors | ErrorModes.NoGpFaultErrorBox))
+                {
+                    process = Process.Start(startInfo);
+                    process.PriorityClass = ProcessPriorityClass.Idle;
+                }
+            }
+
+            return process;
+        }
+
+        // http://csharptest.net/532/using-processstart-to-capture-console-output/
+        public static int Run(Action<string> output, Action<string> errorOutput, TextReader input, string exe, string args, string workingDirectory, params KeyValuePair<string, string>[] environmentalVariables)
+        {
+            if (String.IsNullOrEmpty(exe))
+            {
+                throw new FileNotFoundException();
+            }
+
+            if (output == null)
+            {
+                throw new ArgumentNullException("output");
+            }
+
+            var psi = new ProcessStartInfo
+            {
+                UseShellExecute = false,
+                RedirectStandardError = true,
+                RedirectStandardOutput = true,
+                RedirectStandardInput = true,
+                WindowStyle = ProcessWindowStyle.Hidden,
+                CreateNoWindow = true,
+                ErrorDialog = false,
+                WorkingDirectory = workingDirectory ?? Environment.CurrentDirectory,
+                FileName = exe,
+                Arguments = args
+            };
+
+            foreach (var environmentalVariable in environmentalVariables)
+            {
+                if (!psi.EnvironmentVariables.ContainsKey(environmentalVariable.Key) && environmentalVariable.Value != null)
+                    psi.EnvironmentVariables.Add(environmentalVariable.Key, environmentalVariable.Value);
+                if (psi.EnvironmentVariables.ContainsKey(environmentalVariable.Key) && environmentalVariable.Value == null)
+                    psi.EnvironmentVariables.Remove(environmentalVariable.Key);
+            }
+
+            using (var process = Process.Start(psi))
+            {
+                using (var mreOut = new ManualResetEvent(false))
+                {
+                    using (var mreErr = new ManualResetEvent(false))
+                    {
+                        process.EnableRaisingEvents = true;
+                        process.OutputDataReceived += (o, e) =>
+                        {
+                            // ReSharper disable once AccessToDisposedClosure
+                            if (e.Data == null)
+                            {
+                                mreOut.Set();
+                            }
+                            else
+                            {
+                                output(e.Data);
+                            }
+                        };
+                        process.BeginOutputReadLine();
+                        process.ErrorDataReceived += (o, e) =>
+                        {
+                            // ReSharper disable once AccessToDisposedClosure
+                            if (e.Data == null)
+                            {
+                                mreErr.Set();
+                            }
+                            else
+                            {
+                                errorOutput(e.Data);
+                            }
+                        };
+
+                        process.BeginErrorReadLine();
+
+                        string line;
+                        while (input != null && null != (line = input.ReadLine()))
+                        {
+                            process.StandardInput.WriteLine(line);
+                        }
+
+                        process.StandardInput.Close();
+                        process.WaitForExit();
+
+                        mreOut.WaitOne();
+                        mreErr.WaitOne();
+
+                        return process.ExitCode;
+                    }
+                }
+            }
+        }
+
+        [Flags]
+        public enum ErrorModes
+        {
+            Default = 0x0,
+            FailCriticalErrors = 0x1,
+            NoGpFaultErrorBox = 0x2,
+            NoAlignmentFaultExcept = 0x4,
+            NoOpenFileErrorBox = 0x8000
+        }
+
+        public struct ChangeErrorMode : IDisposable
+        {
+            private readonly int _oldMode;
+
+            public ChangeErrorMode(ErrorModes mode)
+            {
+                _oldMode = SetErrorMode((int)mode);
+            }
+
+            void IDisposable.Dispose() { SetErrorMode(_oldMode); }
+
+            [DllImport("kernel32.dll")]
+            static extern int SetErrorMode(int newMode);
+        }
+    }
+}

src/GitTools.Core/Testing/Extensions/GitTestExtensions.cs

@@ -0,0 +1,100 @@
+namespace GitTools.Testing
+{
+    using System;
+    using System.Diagnostics;
+    using System.IO;
+    using System.Linq;
+    using System.Text;
+    using LibGit2Sharp;
+
+    public static class GitTestExtensions
+    {
+        private static int pad = 1;
+
+        public static void DumpGraph(this IRepository repository)
+        {
+            var output = new StringBuilder();
+
+            ProcessHelper.Run(
+                o => output.AppendLine(o),
+                e => output.AppendLineFormat("ERROR: {0}", e),
+                null,
+                "git",
+                @"log --graph --abbrev-commit --decorate --date=relative --all",
+                repository.Info.Path);
+
+            Trace.Write(output.ToString());
+        }
+
+        public static Commit MakeACommit(this IRepository repository)
+        {
+            return CreateFileAndCommit(repository, Guid.NewGuid().ToString());
+        }
+
+        public static void MergeNoFF(this IRepository repository, string branch)
+        {
+            MergeNoFF(repository, branch, TestValues.SignatureNow());
+        }
+
+        public static void MergeNoFF(this IRepository repository, string branch, Signature sig)
+        {
+            // Fixes a race condition
+            repository.Merge(repository.FindBranch(branch), sig, new MergeOptions
+            {
+                FastForwardStrategy = FastForwardStrategy.NoFastFoward
+            });
+        }
+
+        public static Commit[] MakeCommits(this IRepository repository, int numCommitsToMake)
+        {
+            return Enumerable.Range(1, numCommitsToMake)
+                             .Select(x => repository.MakeACommit())
+                             .ToArray();
+        }
+
+        public static Commit CreateFileAndCommit(this IRepository repository, string relativeFileName)
+        {
+            var randomFile = Path.Combine(repository.Info.WorkingDirectory, relativeFileName);
+            if (File.Exists(randomFile))
+            {
+                File.Delete(randomFile);
+            }
+
+            var totalWidth = 36 + (pad++ % 10);
+            var contents = Guid.NewGuid().ToString().PadRight(totalWidth, '.');
+            File.WriteAllText(randomFile, contents);
+
+            repository.Stage(randomFile);
+
+            return repository.Commit(string.Format("Test Commit for file '{0}'", relativeFileName),
+                TestValues.SignatureNow(), TestValues.SignatureNow());
+        }
+
+        public static Tag MakeATaggedCommit(this IRepository repository, string tag)
+        {
+            var commit = repository.MakeACommit();
+            var existingTag = repository.Tags.SingleOrDefault(t => t.Name == tag);
+            if (existingTag != null)
+                return existingTag;
+            return repository.Tags.Add(tag, commit);
+        }
+
+        public static Branch CreatePullRequest(this IRepository repository, string from, string to, int prNumber = 2, bool isRemotePr = true)
+        {
+            repository.Checkout(to);
+            repository.MergeNoFF(from);
+            var branch = repository.CreateBranch("pull/" + prNumber + "/merge");
+            repository.Checkout(branch.Name);
+            repository.Checkout(to);
+            repository.Reset(ResetMode.Hard, "HEAD~1");
+            var pullBranch = repository.Checkout("pull/" + prNumber + "/merge");
+            if (isRemotePr)
+            {
+                // If we delete the branch, it is effectively the same as remote PR
+                repository.Branches.Remove(from);
+            }
+
+            return pullBranch;
+        }
+    }
+}

src/GitTools.Core/Testing/Fixtures/EmptyRepositoryFixture.cs

@@ -0,0 +1,26 @@
+namespace GitTools.Testing
+{
+    using System;
+    using LibGit2Sharp;
+
+    public class EmptyRepositoryFixture : RepositoryFixtureBase
+    {
+        public EmptyRepositoryFixture() :
+            base(CreateNewRepository)
+        {
+        }
+
+        public void DumpGraph()
+        {
+            Repository.DumpGraph();
+        }
+
+        private static IRepository CreateNewRepository(string path)
+        {
+            LibGit2Sharp.Repository.Init(path);
+            Console.WriteLine("Created git repository at '{0}'", path);
+
+            return new Repository(path);
+        }
+    }
+}

src/GitTools.Core/Testing/Fixtures/RemoteRepositoryFixture.cs

@@ -0,0 +1,41 @@
+namespace GitTools.Testing
+{
+    using System;
+    using LibGit2Sharp;
+
+    public class RemoteRepositoryFixture : RepositoryFixtureBase
+    {
+        public IRepository LocalRepository;
+        public string LocalRepositoryPath;
+
+        public RemoteRepositoryFixture()
+            : base(CreateNewRepository)
+        {
+            CloneRepository();
+        }
+
+        private static IRepository CreateNewRepository(string path)
+        {
+            LibGit2Sharp.Repository.Init(path);
+            Console.WriteLine("Created git repository at '{0}'", path);
+
+            var repo = new Repository(path);
+            repo.MakeCommits(5);
+            return repo;
+        }
+
+        private void CloneRepository()
+        {
+            LocalRepositoryPath = TemporaryFilesContext.GetDirectory("/");
+            LibGit2Sharp.Repository.Clone(RepositoryPath, LocalRepositoryPath);
+            LocalRepository = new Repository(LocalRepositoryPath);
+        }
+
+        public override void Dispose()
+        {
+            LocalRepository.Dispose();
+
+            base.Dispose();
+        }
+    }
+}