Merge pull request #38 from github-for-unity/lfs-2.2

shana · web-flow · commit c0b4bb4e95da · 2017-06-28T10:00:52.000+02:00
Bump lfs to 2.2
diff --git a/src/GitHub.Api/Application/ApplicationManagerBase.cs b/src/GitHub.Api/Application/ApplicationManagerBase.cs
@@ -55,7 +55,7 @@ public virtual async Task Run(bool firstRun)
                 var progress = new ProgressReport();
 
                 var gitClient = new GitClient(Environment, ProcessManager, Platform.CredentialManager, TaskManager);
-                var gitSetup = new GitSetup(Environment, CancellationToken);
+                var gitSetup = new GitInstaller(Environment, CancellationToken);
                 var expectedPath = gitSetup.GitInstallationPath;
                 var setupDone = await gitSetup.SetupIfNeeded(progress.Percentage, progress.Remaining);
                 if (setupDone)
diff --git a/src/GitHub.Api/Git/GitSetup.cs b/src/GitHub.Api/Git/GitSetup.cs
diff --git a/src/GitHub.Api/GitHub.Api.csproj b/src/GitHub.Api/GitHub.Api.csproj
@@ -110,7 +110,6 @@
     <Compile Include="Events\RepositoryWatcher.cs" />
     <Compile Include="Extensions\FileSystemExtensions.cs" />
     <Compile Include="Extensions\StreamExtensions.cs" />
-    <Compile Include="Git\GitSetup.cs" />
     <Compile Include="Git\GitFileStatus.cs" />
     <Compile Include="Git\GitLock.cs" />
     <Compile Include="Git\GitObjectFactory.cs" />
diff --git a/src/GitHub.Api/Installer/GitInstaller.cs b/src/GitHub.Api/Installer/GitInstaller.cs
@@ -6,7 +6,8 @@ namespace GitHub.Unity
 {
     class GitInstaller : IGitInstaller
     {
-        public const string GitLfsExecutableMD5 = "63700E111EF68EE1AD866C2C4373B68D";
+        public const string WindowsGitLfsExecutableMD5 = "7cfa21e5e9f9819a7cb0c317b0be1c5b";
+        public const string MacGitLfsExecutableMD5 = "54f586df05a4b80feae4fabed10d8e95";
 
         private const string PortableGitExpectedVersion = "f02737a78695063deace08e96d5042710d3e32db";
         private const string PackageName = "PortableGit";
@@ -40,7 +41,7 @@ public GitInstaller(IEnvironment environment, IZipHelper sharpZipLibHelper, Canc
                  : ZipHelper.ExtractZipFile;
 
 
-            PackageDestinationDirectory = environment.GetSpecialFolder(Environment.SpecialFolder.LocalApplicationData)
+            GitInstallationPath = environment.GetSpecialFolder(Environment.SpecialFolder.LocalApplicationData)
                 .ToNPath().Combine(ApplicationInfo.ApplicationName, PackageNameWithVersion);
             var gitExecutable = "git";
             var gitLfsExecutable = "git-lfs";
@@ -52,21 +53,21 @@ public GitInstaller(IEnvironment environment, IZipHelper sharpZipLibHelper, Canc
             GitLfsExecutable = gitLfsExecutable;
             GitExecutable = gitExecutable;
 
-            GitDestinationPath = PackageDestinationDirectory;
+            GitExecutablePath = GitInstallationPath;
             if (DefaultEnvironment.OnWindows)
-                GitDestinationPath = GitDestinationPath.Combine("cmd");
+                GitExecutablePath = GitExecutablePath.Combine("cmd");
             else
-                GitDestinationPath = GitDestinationPath.Combine("bin");
-            GitDestinationPath = GitDestinationPath.Combine(GitExecutable);
+                GitExecutablePath = GitExecutablePath.Combine("bin");
+            GitExecutablePath = GitExecutablePath.Combine(GitExecutable);
 
-            GitLfsDestinationPath = PackageDestinationDirectory;
+            GitLfsExecutablePath = GitInstallationPath;
 
             if (DefaultEnvironment.OnWindows)
             {
-                GitLfsDestinationPath = GitLfsDestinationPath.Combine("mingw32");
+                GitLfsExecutablePath = GitLfsExecutablePath.Combine("mingw32");
             }
 
-            GitLfsDestinationPath = GitLfsDestinationPath.Combine("libexec", "git-core", GitLfsExecutable);
+            GitLfsExecutablePath = GitLfsExecutablePath.Combine("libexec", "git-core", GitLfsExecutable);
         }
 
         public bool IsExtracted()
@@ -76,9 +77,9 @@ public bool IsExtracted()
 
         private bool IsPortableGitExtracted()
         {
-            if (!GitDestinationPath.FileExists())
+            if (!GitExecutablePath.FileExists())
             {
-                logger.Trace("{0} not installed yet", GitDestinationPath);
+                logger.Trace("{0} not installed yet", GitExecutablePath);
                 return false;
             }
 
@@ -89,18 +90,18 @@ private bool IsPortableGitExtracted()
 
         public bool IsGitLfsExtracted()
         {
-            if (!GitLfsDestinationPath.FileExists())
+            if (!GitLfsExecutablePath.FileExists())
             {
-                logger.Trace("{0} not installed yet", GitLfsDestinationPath);
+                logger.Trace("{0} not installed yet", GitLfsExecutablePath);
                 return false;
             }
 
-            var calculateMd5 = environment.FileSystem.CalculateMD5(GitLfsDestinationPath);
+            var calculateMd5 = environment.FileSystem.CalculateMD5(GitLfsExecutablePath);
             logger.Trace("GitLFS MD5: {0}", calculateMd5);
-
-            if (calculateMd5 != GitLfsExecutableMD5)
+            var md5 = environment.IsWindows ? WindowsGitLfsExecutableMD5 : MacGitLfsExecutableMD5;
+            if (String.Compare(calculateMd5, md5, true) != 0)
             {
-                logger.Trace("{0} has incorrect MD5", GitDestinationPath);
+                logger.Trace("{0} has incorrect MD5", GitExecutablePath);
                 return false;
             }
 
@@ -156,7 +157,7 @@ public Task<bool> SetupGitIfNeeded(NPath tempPath, IProgress<float> zipFileProgr
 
             if (IsPortableGitExtracted())
             {
-                logger.Trace("Already extracted {0}, returning", PackageDestinationDirectory);
+                logger.Trace("Already extracted {0}, returning", GitInstallationPath);
                 return TaskEx.FromResult(true);
             }
 
@@ -196,16 +197,16 @@ public Task<bool> SetupGitIfNeeded(NPath tempPath, IProgress<float> zipFileProgr
 
             try
             {
-                PackageDestinationDirectory.DeleteIfExists();
-                PackageDestinationDirectory.EnsureParentDirectoryExists();
+                GitInstallationPath.DeleteIfExists();
+                GitInstallationPath.EnsureParentDirectoryExists();
 
-                logger.Trace("Moving \"{0}\" to \"{1}\"", unzipPath, PackageDestinationDirectory);
+                logger.Trace("Moving \"{0}\" to \"{1}\"", unzipPath, GitInstallationPath);
 
-                unzipPath.Move(PackageDestinationDirectory);
+                unzipPath.Move(GitInstallationPath);
             }
             catch (Exception ex)
             {
-                logger.Error(ex, "Error Moving \"{0}\" to \"{1}\"", tempPath, PackageDestinationDirectory);
+                logger.Error(ex, "Error Moving \"{0}\" to \"{1}\"", tempPath, GitInstallationPath);
                 return TaskEx.FromResult(false);
             }
             unzipPath.DeleteIfExists();
@@ -221,7 +222,7 @@ public Task<bool> SetupGitLfsIfNeeded(NPath tempPath, IProgress<float> zipFilePr
 
             if (IsGitLfsExtracted())
             {
-                logger.Trace("Already extracted {0}, returning", GitLfsDestinationPath);
+                logger.Trace("Already extracted {0}, returning", GitLfsExecutablePath);
                 return TaskEx.FromResult(false);
             }
 
@@ -262,13 +263,13 @@ public Task<bool> SetupGitLfsIfNeeded(NPath tempPath, IProgress<float> zipFilePr
             try
             {
                 var unzippedGitLfsExecutablePath = unzipPath.Combine(GitLfsExecutable);
-                logger.Trace("Copying \"{0}\" to \"{1}\"", unzippedGitLfsExecutablePath, GitLfsDestinationPath);
+                logger.Trace("Copying \"{0}\" to \"{1}\"", unzippedGitLfsExecutablePath, GitLfsExecutablePath);
 
-                unzippedGitLfsExecutablePath.Copy(GitLfsDestinationPath);
+                unzippedGitLfsExecutablePath.Copy(GitLfsExecutablePath);
             }
             catch (Exception ex)
             {
-                logger.Error(ex, "Error Copying git-lfs Source:\"{0}\" Destination:\"{1}\"", unzipPath, GitLfsDestinationPath);
+                logger.Error(ex, "Error Copying git-lfs Source:\"{0}\" Destination:\"{1}\"", unzipPath, GitLfsExecutablePath);
                 return TaskEx.FromResult(false);
             }
             unzipPath.DeleteIfExists();
@@ -280,11 +281,11 @@ private NPath GetTemporaryPath()
             return NPath.CreateTempDirectory(TempPathPrefix);
         }
 
-        public NPath PackageDestinationDirectory { get; private set; }
+        public NPath GitInstallationPath { get; private set; }
 
-        public NPath GitLfsDestinationPath { get; private set; }
+        public NPath GitLfsExecutablePath { get; private set; }
 
-        public NPath GitDestinationPath { get; private set; }
+        public NPath GitExecutablePath { get; private set; }
         public string PackageNameWithVersion => PackageName + "_" + PortableGitExpectedVersion;
 
         private string GitLfsExecutable { get; set; }
diff --git a/src/GitHub.Api/Installer/IGitInstaller.cs b/src/GitHub.Api/Installer/IGitInstaller.cs
@@ -7,7 +7,7 @@ namespace GitHub.Unity
     interface IGitInstaller
     {
         bool IsExtracted();
-        NPath PackageDestinationDirectory { get; }
+        NPath GitInstallationPath { get; }
         string PackageNameWithVersion { get; }
     }
 }
diff --git a/src/GitHub.Api/PlatformResources/mac/git-lfs.zip b/src/GitHub.Api/PlatformResources/mac/git-lfs.zip
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:68434557f74b3d22406ee18e4032fecbf743865378830b6fef283ac022a6e00c
-size 2617036
+oid sha256:749d4f91993eb4526f3667e524b9902e2d909fcd2a9ea8ee6025177eb16817f0
+size 2736142
diff --git a/src/GitHub.Api/PlatformResources/windows/git-lfs.zip b/src/GitHub.Api/PlatformResources/windows/git-lfs.zip
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:04b6e46a033a3cb289c7a3bfedd976e28eeeb50f6f399b528d6dafd19a4ae11f
-size 2674166
+oid sha256:9aac2fdc3d1527ee6c796e4364eafeacbbeefc38714a4df63fb7c8a1ec7bcff5
+size 2596848
diff --git a/src/tests/IntegrationTests/BaseGitEnvironmentTest.cs b/src/tests/IntegrationTests/BaseGitEnvironmentTest.cs
@@ -16,7 +16,7 @@ protected async Task<IEnvironment> Initialize(NPath repoPath, NPath environmentP
 
             Environment = new IntegrationTestEnvironment(repoPath, SolutionDirectory, environmentPath, enableEnvironmentTrace);
 
-            var gitSetup = new GitSetup(Environment, TaskManager.Token);
+            var gitSetup = new GitInstaller(Environment, TaskManager.Token);
             await gitSetup.SetupIfNeeded();
             Environment.GitExecutablePath = gitSetup.GitExecutablePath;
 
diff --git a/src/tests/IntegrationTests/Git/GitSetupTests.cs b/src/tests/IntegrationTests/Git/GitSetupTests.cs
@@ -16,14 +16,14 @@ public async Task InstallGit()
             var environmentPath = NPath.CreateTempDirectory("integration-test-environment");
             var environment = await Initialize(TestRepoMasterDirtyUnsynchronized, environmentPath);
 
-            var gitSetup = new GitSetup(environment, TaskManager.Token);
+            var gitSetup = new GitInstaller(environment, TaskManager.Token);
             var expectedPath = gitSetup.GitInstallationPath;
 
             var setupDone = false;
             var percent = -1f;
             gitSetup.GitExecutablePath.FileExists().Should().BeFalse();
 
-            setupDone = await gitSetup.SetupIfNeeded(percentage: new Progress<float>(x => percent = x));
+            setupDone = await gitSetup.SetupIfNeeded(new Progress<float>(x => percent = x));
 
             if (environment.IsWindows)
             {
@@ -42,9 +42,9 @@ public async Task InstallGit()
                 gitLfsDestinationPath.FileExists().Should().BeTrue();
 
                 var calculateMd5 = NPath.FileSystem.CalculateMD5(gitLfsDestinationPath);
-                GitInstaller.GitLfsExecutableMD5.Should().Be(calculateMd5);
+                Assert.IsTrue(string.Compare(calculateMd5, GitInstaller.WindowsGitLfsExecutableMD5, true) == 0);
 
-                setupDone = await gitSetup.SetupIfNeeded(percentage: new Progress<float>(x => percent = x));
+                setupDone = await gitSetup.SetupIfNeeded(new Progress<float>(x => percent = x));
                 setupDone.Should().BeFalse();
             }
             else
@@ -84,7 +84,7 @@ public void VerifyGitLfsBundle()
             gitLfsPath.Exists().Should().BeTrue();
 
             var calculateMd5 = NPath.FileSystem.CalculateMD5(gitLfsPath);
-            GitInstaller.GitLfsExecutableMD5.Should().Be(calculateMd5);
+            Assert.IsTrue(string.Compare(calculateMd5, GitInstaller.WindowsGitLfsExecutableMD5, true) == 0);
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,8 @@ namespace GitHub.Unity`
`6`	`6`	`{`
`7`	`7`	`class GitInstaller : IGitInstaller`
`8`	`8`	`{`
`9`		`- public const string GitLfsExecutableMD5 = "63700E111EF68EE1AD866C2C4373B68D";`
	`9`	`+ public const string WindowsGitLfsExecutableMD5 = "7cfa21e5e9f9819a7cb0c317b0be1c5b";`
	`10`	`+ public const string MacGitLfsExecutableMD5 = "54f586df05a4b80feae4fabed10d8e95";`
`10`	`11`
`11`	`12`	`private const string PortableGitExpectedVersion = "f02737a78695063deace08e96d5042710d3e32db";`
`12`	`13`	`private const string PackageName = "PortableGit";`
`@@ -40,7 +41,7 @@ public GitInstaller(IEnvironment environment, IZipHelper sharpZipLibHelper, Canc`
`40`	`41`	`: ZipHelper.ExtractZipFile;`
`41`	`42`
`42`	`43`
`43`		`- PackageDestinationDirectory = environment.GetSpecialFolder(Environment.SpecialFolder.LocalApplicationData)`
	`44`	`+ GitInstallationPath = environment.GetSpecialFolder(Environment.SpecialFolder.LocalApplicationData)`
`44`	`45`	`.ToNPath().Combine(ApplicationInfo.ApplicationName, PackageNameWithVersion);`
`45`	`46`	`var gitExecutable = "git";`
`46`	`47`	`var gitLfsExecutable = "git-lfs";`
`@@ -52,21 +53,21 @@ public GitInstaller(IEnvironment environment, IZipHelper sharpZipLibHelper, Canc`
`52`	`53`	`GitLfsExecutable = gitLfsExecutable;`
`53`	`54`	`GitExecutable = gitExecutable;`
`54`	`55`
`55`		`- GitDestinationPath = PackageDestinationDirectory;`
	`56`	`+ GitExecutablePath = GitInstallationPath;`
`56`	`57`	`if (DefaultEnvironment.OnWindows)`
`57`		`- GitDestinationPath = GitDestinationPath.Combine("cmd");`
	`58`	`+ GitExecutablePath = GitExecutablePath.Combine("cmd");`
`58`	`59`	`else`
`59`		`- GitDestinationPath = GitDestinationPath.Combine("bin");`
`60`		`- GitDestinationPath = GitDestinationPath.Combine(GitExecutable);`
	`60`	`+ GitExecutablePath = GitExecutablePath.Combine("bin");`
	`61`	`+ GitExecutablePath = GitExecutablePath.Combine(GitExecutable);`
`61`	`62`
`62`		`- GitLfsDestinationPath = PackageDestinationDirectory;`
	`63`	`+ GitLfsExecutablePath = GitInstallationPath;`
`63`	`64`
`64`	`65`	`if (DefaultEnvironment.OnWindows)`
`65`	`66`	`{`
`66`		`- GitLfsDestinationPath = GitLfsDestinationPath.Combine("mingw32");`
	`67`	`+ GitLfsExecutablePath = GitLfsExecutablePath.Combine("mingw32");`
`67`	`68`	`}`
`68`	`69`
`69`		`- GitLfsDestinationPath = GitLfsDestinationPath.Combine("libexec", "git-core", GitLfsExecutable);`
	`70`	`+ GitLfsExecutablePath = GitLfsExecutablePath.Combine("libexec", "git-core", GitLfsExecutable);`
`70`	`71`	`}`
`71`	`72`
`72`	`73`	`public bool IsExtracted()`
`@@ -76,9 +77,9 @@ public bool IsExtracted()`
`76`	`77`
`77`	`78`	`private bool IsPortableGitExtracted()`
`78`	`79`	`{`
`79`		`- if (!GitDestinationPath.FileExists())`
	`80`	`+ if (!GitExecutablePath.FileExists())`
`80`	`81`	`{`
`81`		`- logger.Trace("{0} not installed yet", GitDestinationPath);`
	`82`	`+ logger.Trace("{0} not installed yet", GitExecutablePath);`
`82`	`83`	`return false;`
`83`	`84`	`}`
`84`	`85`
`@@ -89,18 +90,18 @@ private bool IsPortableGitExtracted()`
`89`	`90`
`90`	`91`	`public bool IsGitLfsExtracted()`
`91`	`92`	`{`
`92`		`- if (!GitLfsDestinationPath.FileExists())`
	`93`	`+ if (!GitLfsExecutablePath.FileExists())`
`93`	`94`	`{`
`94`		`- logger.Trace("{0} not installed yet", GitLfsDestinationPath);`
	`95`	`+ logger.Trace("{0} not installed yet", GitLfsExecutablePath);`
`95`	`96`	`return false;`
`96`	`97`	`}`
`97`	`98`
`98`		`- var calculateMd5 = environment.FileSystem.CalculateMD5(GitLfsDestinationPath);`
	`99`	`+ var calculateMd5 = environment.FileSystem.CalculateMD5(GitLfsExecutablePath);`
`99`	`100`	`logger.Trace("GitLFS MD5: {0}", calculateMd5);`
`100`		`-`
`101`		`- if (calculateMd5 != GitLfsExecutableMD5)`
	`101`	`+ var md5 = environment.IsWindows ? WindowsGitLfsExecutableMD5 : MacGitLfsExecutableMD5;`
	`102`	`+ if (String.Compare(calculateMd5, md5, true) != 0)`
`102`	`103`	`{`
`103`		`- logger.Trace("{0} has incorrect MD5", GitDestinationPath);`
	`104`	`+ logger.Trace("{0} has incorrect MD5", GitExecutablePath);`
`104`	`105`	`return false;`
`105`	`106`	`}`
`106`	`107`
`@@ -156,7 +157,7 @@ public Task<bool> SetupGitIfNeeded(NPath tempPath, IProgress<float> zipFileProgr`
`156`	`157`
`157`	`158`	`if (IsPortableGitExtracted())`
`158`	`159`	`{`
`159`		`- logger.Trace("Already extracted {0}, returning", PackageDestinationDirectory);`
	`160`	`+ logger.Trace("Already extracted {0}, returning", GitInstallationPath);`
`160`	`161`	`return TaskEx.FromResult(true);`
`161`	`162`	`}`
`162`	`163`
`@@ -196,16 +197,16 @@ public Task<bool> SetupGitIfNeeded(NPath tempPath, IProgress<float> zipFileProgr`
`196`	`197`
`197`	`198`	`try`
`198`	`199`	`{`
`199`		`- PackageDestinationDirectory.DeleteIfExists();`
`200`		`- PackageDestinationDirectory.EnsureParentDirectoryExists();`
	`200`	`+ GitInstallationPath.DeleteIfExists();`
	`201`	`+ GitInstallationPath.EnsureParentDirectoryExists();`
`201`	`202`
`202`		`- logger.Trace("Moving \"{0}\" to \"{1}\"", unzipPath, PackageDestinationDirectory);`
	`203`	`+ logger.Trace("Moving \"{0}\" to \"{1}\"", unzipPath, GitInstallationPath);`
`203`	`204`
`204`		`- unzipPath.Move(PackageDestinationDirectory);`
	`205`	`+ unzipPath.Move(GitInstallationPath);`
`205`	`206`	`}`
`206`	`207`	`catch (Exception ex)`
`207`	`208`	`{`
`208`		`- logger.Error(ex, "Error Moving \"{0}\" to \"{1}\"", tempPath, PackageDestinationDirectory);`
	`209`	`+ logger.Error(ex, "Error Moving \"{0}\" to \"{1}\"", tempPath, GitInstallationPath);`
`209`	`210`	`return TaskEx.FromResult(false);`
`210`	`211`	`}`
`211`	`212`	`unzipPath.DeleteIfExists();`
`@@ -221,7 +222,7 @@ public Task<bool> SetupGitLfsIfNeeded(NPath tempPath, IProgress<float> zipFilePr`
`221`	`222`
`222`	`223`	`if (IsGitLfsExtracted())`
`223`	`224`	`{`
`224`		`- logger.Trace("Already extracted {0}, returning", GitLfsDestinationPath);`
	`225`	`+ logger.Trace("Already extracted {0}, returning", GitLfsExecutablePath);`
`225`	`226`	`return TaskEx.FromResult(false);`
`226`	`227`	`}`
`227`	`228`
`@@ -262,13 +263,13 @@ public Task<bool> SetupGitLfsIfNeeded(NPath tempPath, IProgress<float> zipFilePr`
`262`	`263`	`try`
`263`	`264`	`{`
`264`	`265`	`var unzippedGitLfsExecutablePath = unzipPath.Combine(GitLfsExecutable);`
`265`		`- logger.Trace("Copying \"{0}\" to \"{1}\"", unzippedGitLfsExecutablePath, GitLfsDestinationPath);`
	`266`	`+ logger.Trace("Copying \"{0}\" to \"{1}\"", unzippedGitLfsExecutablePath, GitLfsExecutablePath);`
`266`	`267`
`267`		`- unzippedGitLfsExecutablePath.Copy(GitLfsDestinationPath);`
	`268`	`+ unzippedGitLfsExecutablePath.Copy(GitLfsExecutablePath);`
`268`	`269`	`}`
`269`	`270`	`catch (Exception ex)`
`270`	`271`	`{`
`271`		`- logger.Error(ex, "Error Copying git-lfs Source:\"{0}\" Destination:\"{1}\"", unzipPath, GitLfsDestinationPath);`
	`272`	`+ logger.Error(ex, "Error Copying git-lfs Source:\"{0}\" Destination:\"{1}\"", unzipPath, GitLfsExecutablePath);`
`272`	`273`	`return TaskEx.FromResult(false);`
`273`	`274`	`}`
`274`	`275`	`unzipPath.DeleteIfExists();`
`@@ -280,11 +281,11 @@ private NPath GetTemporaryPath()`
`280`	`281`	`return NPath.CreateTempDirectory(TempPathPrefix);`
`281`	`282`	`}`
`282`	`283`
`283`		`- public NPath PackageDestinationDirectory { get; private set; }`
	`284`	`+ public NPath GitInstallationPath { get; private set; }`
`284`	`285`
`285`		`- public NPath GitLfsDestinationPath { get; private set; }`
	`286`	`+ public NPath GitLfsExecutablePath { get; private set; }`
`286`	`287`
`287`		`- public NPath GitDestinationPath { get; private set; }`
	`288`	`+ public NPath GitExecutablePath { get; private set; }`
`288`	`289`	`public string PackageNameWithVersion => PackageName + "_" + PortableGitExpectedVersion;`
`289`	`290`
`290`	`291`	`private string GitLfsExecutable { get; set; }`
Original file line number	Diff line number	Diff line change
`@@ -7,7 +7,7 @@ namespace GitHub.Unity`
`7`	`7`	`interface IGitInstaller`
`8`	`8`	`{`
`9`	`9`	`bool IsExtracted();`
`10`		`- NPath PackageDestinationDirectory { get; }`
	`10`	`+ NPath GitInstallationPath { get; }`
`11`	`11`	`string PackageNameWithVersion { get; }`
`12`	`12`	`}`
`13`	`13`	`}`
Original file line number	Diff line number	Diff line change
`@@ -16,14 +16,14 @@ public async Task InstallGit()`
`16`	`16`	`var environmentPath = NPath.CreateTempDirectory("integration-test-environment");`
`17`	`17`	`var environment = await Initialize(TestRepoMasterDirtyUnsynchronized, environmentPath);`
`18`	`18`
`19`		`- var gitSetup = new GitSetup(environment, TaskManager.Token);`
	`19`	`+ var gitSetup = new GitInstaller(environment, TaskManager.Token);`
`20`	`20`	`var expectedPath = gitSetup.GitInstallationPath;`
`21`	`21`
`22`	`22`	`var setupDone = false;`
`23`	`23`	`var percent = -1f;`
`24`	`24`	`gitSetup.GitExecutablePath.FileExists().Should().BeFalse();`
`25`	`25`
`26`		`- setupDone = await gitSetup.SetupIfNeeded(percentage: new Progress<float>(x => percent = x));`
	`26`	`+ setupDone = await gitSetup.SetupIfNeeded(new Progress<float>(x => percent = x));`
`27`	`27`
`28`	`28`	`if (environment.IsWindows)`
`29`	`29`	`{`
`@@ -42,9 +42,9 @@ public async Task InstallGit()`
`42`	`42`	`gitLfsDestinationPath.FileExists().Should().BeTrue();`
`43`	`43`
`44`	`44`	`var calculateMd5 = NPath.FileSystem.CalculateMD5(gitLfsDestinationPath);`
`45`		`- GitInstaller.GitLfsExecutableMD5.Should().Be(calculateMd5);`
	`45`	`+ Assert.IsTrue(string.Compare(calculateMd5, GitInstaller.WindowsGitLfsExecutableMD5, true) == 0);`
`46`	`46`
`47`		`- setupDone = await gitSetup.SetupIfNeeded(percentage: new Progress<float>(x => percent = x));`
	`47`	`+ setupDone = await gitSetup.SetupIfNeeded(new Progress<float>(x => percent = x));`
`48`	`48`	`setupDone.Should().BeFalse();`
`49`	`49`	`}`
`50`	`50`	`else`
`@@ -84,7 +84,7 @@ public void VerifyGitLfsBundle()`
`84`	`84`	`gitLfsPath.Exists().Should().BeTrue();`
`85`	`85`
`86`	`86`	`var calculateMd5 = NPath.FileSystem.CalculateMD5(gitLfsPath);`
`87`		`- GitInstaller.GitLfsExecutableMD5.Should().Be(calculateMd5);`
	`87`	`+ Assert.IsTrue(string.Compare(calculateMd5, GitInstaller.WindowsGitLfsExecutableMD5, true) == 0);`
`88`	`88`	`}`
`89`	`89`	`}`
`90`	`90`	`}`