Adding more testing for writing multiple pack file.

Exposing libgit2 method to get the pack file hash.
Minor fixes for PackBuilder, PackBuilderResults, and PackBuilderFixture.

Author: AMSadek

LibGit2Sharp.Tests/PackBuilderFixture.cs

@@ -3,6 +3,7 @@
 using System.Linq;
 using LibGit2Sharp.Tests.TestHelpers;
 using Xunit;
+using System.Collections.Generic;
 
 namespace LibGit2Sharp.Tests
 {
@@ -11,85 +12,71 @@ public class PackBuilderFixture : BaseFixture
         [Fact]
         public void TestDefaultPackDelegate()
         {
-            TestIfSameRepoAfterPacking(null);
+            TestBody((repo, options) =>
+            {
+                PackBuilderResults results = repo.ObjectDatabase.Pack(options);
+            });
         }
 
         [Fact]
         public void TestCommitsPerBranchPackDelegate()
         {
-            TestIfSameRepoAfterPacking(AddingObjectIdsTestDelegate);
+            TestBody((repo, options) =>
+            {
+                PackBuilderResults results = repo.ObjectDatabase.Pack(options, builder =>
+                {
+                    foreach (Branch branch in repo.Branches)
+                    {
+                        foreach (Commit commit in branch.Commits)
+                        {
+                            builder.AddRecursively(commit);
+                        }
+                    }
+
+                    foreach (Tag tag in repo.Tags)
+                    {
+                        builder.Add(tag.Target);
+                    }
+                });
+            });
         }
 
         [Fact]
         public void TestCommitsPerBranchIdsPackDelegate()
         {
-            TestIfSameRepoAfterPacking(AddingObjectsTestDelegate);
-        }
-
-        internal void TestIfSameRepoAfterPacking(Action<IRepository, PackBuilder> packDelegate)
-        {
-            // read a repo
-            // pack with the provided action
-            // write the pack file in a mirror repo
-            // read new repo
-            // compare
-
-            string orgRepoPath = SandboxPackBuilderTestRepo();
-            string mrrRepoPath = SandboxPackBuilderTestRepo();
-            string mrrRepoPackDirPath = Path.Combine(mrrRepoPath + "/.git/objects");
-
-            DirectoryHelper.DeleteDirectory(mrrRepoPackDirPath);
-            Directory.CreateDirectory(mrrRepoPackDirPath + "/pack");
-
-            PackBuilderOptions packBuilderOptions = new PackBuilderOptions(mrrRepoPackDirPath + "/pack");
-
-            using (Repository orgRepo = new Repository(orgRepoPath))
+            TestBody((repo, options) =>
             {
-                PackBuilderResults results;
-                if (packDelegate != null)
-                    results = orgRepo.ObjectDatabase.Pack(packBuilderOptions, b => packDelegate(orgRepo, b));
-                else
-                    results = orgRepo.ObjectDatabase.Pack(packBuilderOptions);
-
-                // written objects count is the same as in objects database
-                Assert.Equal(orgRepo.ObjectDatabase.Count(), results.WrittenObjectsCount);
-
-                // loading a repo from the written pack file.
-                using (Repository mrrRepo = new Repository(mrrRepoPath))
+                PackBuilderResults results = repo.ObjectDatabase.Pack(options, builder =>
                 {
-                    // make sure the objects of the original repo are the same as the ones in the mirror repo
-                    // doing that by making sure the count is the same, and the set difference is empty
-                    Assert.True(mrrRepo.ObjectDatabase.Count() == orgRepo.ObjectDatabase.Count() && !mrrRepo.ObjectDatabase.Except(orgRepo.ObjectDatabase).Any());
+                    foreach (Branch branch in repo.Branches)
+                    {
+                        foreach (Commit commit in branch.Commits)
+                        {
+                            builder.AddRecursively(commit.Id);
+                        }
+                    }
 
-                    Assert.Equal(orgRepo.Commits.Count(), mrrRepo.Commits.Count());
-                    Assert.Equal(orgRepo.Branches.Count(), mrrRepo.Branches.Count());
-                    Assert.Equal(orgRepo.Refs.Count(), mrrRepo.Refs.Count());
-                }
-            }
+                    foreach (Tag tag in repo.Tags)
+                    {
+                        builder.Add(tag.Target.Id);
+                    }
+                });
+            });
         }
 
         [Fact]
-        internal void TestCreatingMultiplePackFiles()
+        public void TestCreatingMultiplePackFilesByType()
         {
-            string orgRepoPath = SandboxPackBuilderTestRepo();
-            string mrrRepoPath = SandboxPackBuilderTestRepo();
-            string mrrRepoPackDirPath = Path.Combine(mrrRepoPath + "/.git/objects");
-
-            DirectoryHelper.DeleteDirectory(mrrRepoPackDirPath);
-            Directory.CreateDirectory(mrrRepoPackDirPath + "/pack");
-
-            PackBuilderOptions packBuilderOptions = new PackBuilderOptions(mrrRepoPackDirPath + "/pack");
-
-            using (Repository orgRepo = new Repository(orgRepoPath))
+            TestBody((repo, options) =>
             {
                 long totalNumberOfWrittenObjects = 0;
                 PackBuilderResults results;
 
                 for (int i = 0; i < 3; i++)
                 {
-                    results = results = orgRepo.ObjectDatabase.Pack(packBuilderOptions, b =>
+                    results = repo.ObjectDatabase.Pack(options, b =>
                     {
-                        foreach (GitObject obj in orgRepo.ObjectDatabase)
+                        foreach (GitObject obj in repo.ObjectDatabase)
                         {
                             if (i == 0 && obj is Commit)
                                 b.Add(obj.Id);
@@ -100,55 +87,97 @@ internal void TestCreatingMultiplePackFiles()
                         }
                     });
 
+                    // assert the pack file is written 
+                    Assert.True(File.Exists(Path.Combine(options.PackDirectoryPath, "pack-" + results.PackHash + ".pack")));
+                    Assert.True(File.Exists(Path.Combine(options.PackDirectoryPath, "pack-" + results.PackHash + ".idx")));
+
                     totalNumberOfWrittenObjects += results.WrittenObjectsCount;
                 }
 
-                // written objects count is the same as in objects database
-                Assert.Equal(orgRepo.ObjectDatabase.Count(), totalNumberOfWrittenObjects);
+                // assert total number of written objects count is the same as in objects database
+                Assert.Equal(repo.ObjectDatabase.Count(), totalNumberOfWrittenObjects);
+            });
+        }
 
-                // loading a repo from the written pack file.
-                using (Repository mrrRepo = new Repository(mrrRepoPath))
+        [Fact]
+        public void TestCreatingMultiplePackFilesByCount()
+        {
+            TestBody((repo, options) =>
+            {
+                long totalNumberOfWrittenObjects = 0;
+                PackBuilderResults results;
+
+                List<GitObject> objectsList = repo.ObjectDatabase.ToList();
+                int totalObjectCount = objectsList.Count;
+
+                int currentObject = 0;
+
+                while (currentObject < totalObjectCount)
                 {
-                    // make sure the objects of the original repo are the same as the ones in the mirror repo
-                    // doing that by making sure the count is the same, and the set difference is empty
-                    Assert.True(mrrRepo.ObjectDatabase.Count() == orgRepo.ObjectDatabase.Count() && !mrrRepo.ObjectDatabase.Except(orgRepo.ObjectDatabase).Any());
+                    results = repo.ObjectDatabase.Pack(options, b =>
+                    {
+                        while (currentObject < totalObjectCount)
+                        {
+                            b.Add(objectsList[currentObject]);
 
-                    Assert.Equal(orgRepo.Commits.Count(), mrrRepo.Commits.Count());
-                    Assert.Equal(orgRepo.Branches.Count(), mrrRepo.Branches.Count());
-                    Assert.Equal(orgRepo.Refs.Count(), mrrRepo.Refs.Count());
+                            if (currentObject++ % 100 == 0)
+                                break;
+                        }
+                    });
+
+                    // assert the pack file is written 
+                    Assert.True(File.Exists(Path.Combine(options.PackDirectoryPath, "pack-" + results.PackHash + ".pack")));
+                    Assert.True(File.Exists(Path.Combine(options.PackDirectoryPath, "pack-" + results.PackHash + ".idx")));
+
+                    totalNumberOfWrittenObjects += results.WrittenObjectsCount;
                 }
-            }
+
+                // assert total number of written objects count is the same as in objects database
+                Assert.Equal(repo.ObjectDatabase.Count(), totalNumberOfWrittenObjects);
+            });
         }
 
-        internal void AddingObjectIdsTestDelegate(IRepository repo, PackBuilder builder)
+        [Fact]
+        public void CanWritePackAndIndexFiles()
         {
-            foreach (Branch branch in repo.Branches)
+            using (Repository repo = new Repository(SandboxStandardTestRepo()))
             {
-                foreach (Commit commit in branch.Commits)
-                {
-                    builder.AddRecursively(commit.Id);
-                }
-            }
+                string path = Path.GetTempPath();
+                PackBuilderResults results = repo.ObjectDatabase.Pack(new PackBuilderOptions(path));
 
-            foreach (Tag tag in repo.Tags)
-            {
-                builder.Add(tag.Target.Id);
+                Assert.Equal(repo.ObjectDatabase.Count(), results.WrittenObjectsCount);
+
+                Assert.True(File.Exists(Path.Combine(path, "pack-" + results.PackHash + ".pack")));
+                Assert.True(File.Exists(Path.Combine(path, "pack-" + results.PackHash + ".idx")));
             }
         }
 
-        internal void AddingObjectsTestDelegate(IRepository repo, PackBuilder builder)
+        [Fact]
+        public void TestEmptyPackFile()
         {
-            foreach (Branch branch in repo.Branches)
+            using (Repository repo = new Repository(SandboxPackBuilderTestRepo()))
             {
-                foreach (Commit commit in branch.Commits)
+                string path = Path.GetTempPath();
+                PackBuilderResults results = repo.ObjectDatabase.Pack(new PackBuilderOptions(path), b =>
                 {
-                    builder.AddRecursively(commit);
-                }
+
+                });
+
+                Assert.True(File.Exists(Path.Combine(path, "pack-" + results.PackHash + ".pack")));
+                Assert.True(File.Exists(Path.Combine(path, "pack-" + results.PackHash + ".idx")));
             }
+        }
 
-            foreach (Tag tag in repo.Tags)
+        [Fact]
+        public void TestPackFileForEmptyRepository()
+        {
+            using (Repository repo = new Repository(InitNewRepository()))
             {
-                builder.Add(tag.Target);
+                string path = Path.GetTempPath();
+                PackBuilderResults results = repo.ObjectDatabase.Pack(new PackBuilderOptions(path));
+
+                Assert.True(File.Exists(Path.Combine(path, "pack-" + results.PackHash + ".pack")));
+                Assert.True(File.Exists(Path.Combine(path, "pack-" + results.PackHash + ".idx")));
             }
         }
 
@@ -250,5 +279,43 @@ public void ExceptionIfAddRecursivelyNullObjectID()
                 });
             }
         }
+
+        internal void TestBody(Action<IRepository, PackBuilderOptions> fullPackingAction)
+        {
+            // read a repo, pack with the provided action, write the pack file in a mirror repo, read new repo, compare
+
+            string orgRepoPath = SandboxPackBuilderTestRepo();
+            string mrrRepoPath = SandboxPackBuilderTestRepo();
+            string mrrRepoPackDirPath = Path.Combine(mrrRepoPath + "/.git/objects");
+
+            DirectoryHelper.DeleteDirectory(mrrRepoPackDirPath);
+            Directory.CreateDirectory(mrrRepoPackDirPath + "/pack");
+
+            PackBuilderOptions packBuilderOptions = new PackBuilderOptions(mrrRepoPackDirPath + "/pack");
+
+            using (Repository orgRepo = new Repository(orgRepoPath))
+            {
+                fullPackingAction(orgRepo, packBuilderOptions);
+
+                // loading the mirror repo from the written pack file and make sure it's identical to the original.
+                using (Repository mrrRepo = new Repository(mrrRepoPath))
+                {
+                    AssertIfNotIdenticalRepositories(orgRepo, mrrRepo);
+                }
+            }
+        }
+
+        internal void AssertIfNotIdenticalRepositories(IRepository repo1, IRepository repo2)
+        {
+            // make sure the objects of the original repo are the same as the ones in the mirror repo
+            // doing that by making sure the count is the same, and the set difference is empty
+            Assert.True(repo1.ObjectDatabase.Count() == repo2.ObjectDatabase.Count()
+                && !repo2.ObjectDatabase.Except(repo1.ObjectDatabase).Any());
+
+            Assert.Equal(repo1.Commits.Count(), repo2.Commits.Count());
+            Assert.Equal(repo1.Branches.Count(), repo2.Branches.Count());
+            Assert.Equal(repo1.Refs.Count(), repo2.Refs.Count());
+            Assert.Equal(repo1.Tags.Count(), repo2.Tags.Count());
+        }
     }
 }

LibGit2Sharp/Core/NativeMethods.cs

@@ -983,6 +983,9 @@ internal static extern int git_packbuilder_write(
         [DllImport(libgit2)]
         internal static extern UInt32 git_packbuilder_written(PackBuilderSafeHandle packbuilder);
 
+        [DllImport(libgit2)]
+        internal static extern OidSafeHandle git_packbuilder_hash(PackBuilderSafeHandle packbuilder);
+
         [DllImport(libgit2)]
         internal static extern int git_reference_create(
             out ReferenceSafeHandle reference,

LibGit2Sharp/Core/Proxy.cs

@@ -1616,6 +1616,12 @@ public static uint git_packbuilder_written(PackBuilderSafeHandle packbuilder)
         {
             return NativeMethods.git_packbuilder_written(packbuilder);
         }
+
+        public static ObjectId git_packbuilder_hash(PackBuilderSafeHandle packbuilder)
+        {
+            return NativeMethods.git_packbuilder_hash(packbuilder).MarshalAsObjectId();
+        }
+
         #endregion
 
         #region git_rebase

LibGit2Sharp/ObjectDatabase.cs

@@ -690,7 +690,7 @@ private PackBuilderResults InternalPack(PackBuilderOptions options, Action<PackB
             using (PackBuilder builder = new PackBuilder(repo))
             {
                 // set pre-build options
-                builder.SetMaximumNumberOfThreads(options.MaximumNumberOfThreads);
+               results.ActualNumberOfThreads = builder.SetMaximumNumberOfThreads(options.MaximumNumberOfThreads);
 
                 // call the provided action
                 packDelegate(builder);
@@ -700,6 +700,7 @@ private PackBuilderResults InternalPack(PackBuilderOptions options, Action<PackB
 
                 // adding the results to the PackBuilderResults object
                 results.WrittenObjectsCount = builder.WrittenObjectsCount;
+                results.PackHash = builder.PackHash;
             }
 
             return results;

LibGit2Sharp/PackBuilder.cs

@@ -105,11 +105,21 @@ internal int SetMaximumNumberOfThreads(int nThread)
         /// <summary>
         /// Number of objects the PackBuilder will write out.
         /// </summary>
-        internal long ObjectsCount
+        public long ObjectsCount
         {
             get { return Proxy.git_packbuilder_object_count(packBuilderHandle); }
         }
 
+        /// <summary>
+        /// Gets the pack file's hash
+        /// A pack file's name is derived from the sorted hashing of all object names. 
+        /// This is only correct after the pack file has been written.
+        /// </summary>
+        internal string PackHash
+        {
+            get { return Proxy.git_packbuilder_hash(packBuilderHandle).Sha; }
+        }
+
         /// <summary>
         /// Number of objects the PackBuilder has already written out. 
         /// This is only correct after the pack file has been written.
@@ -131,9 +141,19 @@ internal PackBuilderSafeHandle Handle
     public struct PackBuilderResults
     {
         /// <summary>
-        /// Number of objects the PackBuilder has already written out. 
+        /// Number of objects that the PackBuilder has already written out.
         /// </summary>
         public long WrittenObjectsCount { get; internal set; }
+
+        /// <summary>
+        /// Hash of the pack file that the PackBuilder has already written out.
+        /// </summary>
+        public string PackHash { get; internal set; }
+
+        /// <summary>
+        /// Number of actual threads that the PackBuilder has already used.
+        /// </summary>
+        public int ActualNumberOfThreads { get; internal set; }
     }
 
     /// <summary>