add a test to ensure cache key is same even if normalized again; modify cache factory to traverse refs directory instead of just looking at the timestamp (which changes if renormalized)

Author: tofutim

src/GitVersionCore.Tests/ExecuteCoreTests.cs

@@ -18,6 +18,26 @@ public void SetUp()
         fileSystem = new FileSystem();
     }
 
+    [Test]
+    public void CacheKeySameAfterReNormalizing()
+    {
+        var versionAndBranchFinder = new ExecuteCore(fileSystem);
+
+        RepositoryScope(versionAndBranchFinder, (fixture, vv) =>
+        {
+            var targetUrl = "https://github.com/GitTools/GitVersion.git";
+            var targetBranch = "refs/head/master";
+            var gitPreparer = new GitPreparer(targetUrl, null, new Authentication(), false, fixture.RepositoryPath);
+            var cacheKey1 = GitVersionCacheKeyFactory.Create(fileSystem, gitPreparer, null);
+            gitPreparer.Initialise(true, targetBranch);
+            var cacheKey2 = GitVersionCacheKeyFactory.Create(fileSystem, gitPreparer, null);
+            gitPreparer.Initialise(true, targetBranch);
+            var cacheKey3 = GitVersionCacheKeyFactory.Create(fileSystem, gitPreparer, null);
+
+            cacheKey3.Value.ShouldBe(cacheKey2.Value);
+        });        
+    }
+
     [Test]
     public void CacheFileExistsOnDisk()
     {

src/GitVersionCore/GitVersionCacheKeyFactory.cs

@@ -2,6 +2,7 @@
 {
     using GitVersion.Helpers;
     using System;
+    using System.Collections.Generic;
     using System.IO;
     using System.Security.Cryptography;
     using System.Text;
@@ -23,10 +24,108 @@ private static string GetGitSystemHash(GitPreparer gitPreparer, IFileSystem file
         {
             var dotGitDirectory = gitPreparer.GetDotGitDirectory();
 
-            // Maybe using timestamp in .git/refs directory is enough?
-            var lastGitRefsChangedTicks = fileSystem.GetLastDirectoryWrite(Path.Combine(dotGitDirectory, "refs"));
+            // traverse the directory and get a list of files, use that for GetHash
+            var traverse = TraverseTree(Path.Combine(dotGitDirectory, "refs"));
 
-            return GetHash(dotGitDirectory, lastGitRefsChangedTicks.ToString());
+            return GetHash(traverse.ToArray());
+        }
+
+        // lifted from https://msdn.microsoft.com/en-us/library/bb513869.aspx
+        public static List<string> TraverseTree(string root)
+        {
+            var result = new List<string>();
+            result.Add(root);
+            // Data structure to hold names of subfolders to be
+            // examined for files.
+            Stack<string> dirs = new Stack<string>(20);
+
+            if (!System.IO.Directory.Exists(root))
+            {
+                throw new ArgumentException();
+            }
+
+            dirs.Push(root);
+
+            while (dirs.Count > 0)
+            {
+                string currentDir = dirs.Pop();
+
+                var di = new DirectoryInfo(currentDir);
+                result.Add(di.Name);
+
+                string[] subDirs;
+                try
+                {
+                    subDirs = System.IO.Directory.GetDirectories(currentDir);
+                }
+                // An UnauthorizedAccessException exception will be thrown if we do not have
+                // discovery permission on a folder or file. It may or may not be acceptable 
+                // to ignore the exception and continue enumerating the remaining files and 
+                // folders. It is also possible (but unlikely) that a DirectoryNotFound exception 
+                // will be raised. This will happen if currentDir has been deleted by
+                // another application or thread after our call to Directory.Exists. The 
+                // choice of which exceptions to catch depends entirely on the specific task 
+                // you are intending to perform and also on how much you know with certainty 
+                // about the systems on which this code will run.
+                catch (UnauthorizedAccessException e)
+                {
+                    Logger.WriteError(e.Message);
+                    continue;
+                }
+                catch (System.IO.DirectoryNotFoundException e)
+                {
+                    Logger.WriteError(e.Message);
+                    continue;
+                }
+
+                string[] files = null;
+                try
+                {
+                    files = System.IO.Directory.GetFiles(currentDir);
+                }
+
+                catch (UnauthorizedAccessException e)
+                {
+                    Logger.WriteError(e.Message);
+                    continue;
+                }
+
+                catch (System.IO.DirectoryNotFoundException e)
+                {
+                    Logger.WriteError(e.Message);
+                    continue;
+                }
+                // Perform the required action on each file here.
+                // Modify this block to perform your required task.
+                foreach (string file in files)
+                {
+                    try
+                    {
+                        // Perform whatever action is required in your scenario.
+                        System.IO.FileInfo fi = new System.IO.FileInfo(file);
+                        result.Add(fi.Name);
+                        Logger.WriteInfo(string.Format("{0}: {1}, {2}", fi.Name, fi.Length, fi.CreationTime));
+                    }
+                    catch (System.IO.FileNotFoundException e)
+                    {
+                        // If file was deleted by a separate application
+                        //  or thread since the call to TraverseTree()
+                        // then just continue.
+                        Logger.WriteError(e.Message);
+                        continue;
+                    }
+                }
+
+                // Push the subdirectories onto the stack for traversal.
+                // This could also be done before handing the files.
+                // push in reverse order
+                for (int i = subDirs.Length - 1; i >= 0; i--)
+                {
+                    dirs.Push(subDirs[i]);
+                }
+            }
+
+            return result;
         }
 
         private static string GetRepositorySnapshotHash(GitPreparer gitPreparer)