Update working directory on Checkout

Author: jamill

LibGit2Sharp.Tests/CheckoutFixture.cs

@@ -1,12 +1,17 @@
-using System;
+using System;
 using LibGit2Sharp.Tests.TestHelpers;
 using Xunit;
 using Xunit.Extensions;
+using System.IO;
 
 namespace LibGit2Sharp.Tests
 {
     public class CheckoutFixture : BaseFixture
     {
+        private static readonly string originalFilePath = "a.txt";
+        private static readonly string originalFileContent = "Hello";
+        private static readonly string otherBranchName = "other";
+
         [Theory]
         [InlineData("i-do-numbers")]
         [InlineData("diff-test-cases")]
@@ -18,6 +23,10 @@ public void CanCheckoutAnExistingBranch(string branchName)
                 Branch master = repo.Branches["master"];
                 Assert.True(master.IsCurrentRepositoryHead);
 
+                // Hard reset to ensure that working directory, index, and HEAD match
+                repo.Reset(ResetOptions.Hard);
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+
                 Branch branch = repo.Branches[branchName];
                 Assert.NotNull(branch);
 
@@ -29,6 +38,9 @@ public void CanCheckoutAnExistingBranch(string branchName)
                 Assert.Equal(repo.Head, test);
 
                 Assert.False(master.IsCurrentRepositoryHead);
+
+                // Working directory should not be dirty
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
             }
         }
 
@@ -43,6 +55,10 @@ public void CanCheckoutAnExistingBranchByName(string branchName)
                 Branch master = repo.Branches["master"];
                 Assert.True(master.IsCurrentRepositoryHead);
 
+                // Hard reset to ensure that working directory, index, and HEAD match
+                repo.Reset(ResetOptions.Hard);
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+
                 Branch test = repo.Checkout(branchName);
                 Assert.False(repo.Info.IsHeadDetached);
 
@@ -51,6 +67,9 @@ public void CanCheckoutAnExistingBranchByName(string branchName)
                 Assert.Equal(repo.Head, test);
 
                 Assert.False(master.IsCurrentRepositoryHead);
+
+                // Working directory should not be dirty
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
             }
         }
 
@@ -65,12 +84,17 @@ public void CanCheckoutAnArbitraryCommit(string commitPointer)
                 Branch master = repo.Branches["master"];
                 Assert.True(master.IsCurrentRepositoryHead);
 
+                // Hard reset to ensure that working directory, index, and HEAD match
+                repo.Reset(ResetOptions.Hard);
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+
                 Branch detachedHead = repo.Checkout(commitPointer);
 
                 Assert.Equal(repo.Head, detachedHead);
                 Assert.Equal(repo.Lookup(commitPointer).Sha, detachedHead.Tip.Sha);
                 Assert.True(repo.Head.IsCurrentRepositoryHead);
                 Assert.True(repo.Info.IsHeadDetached);
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
 
                 Assert.True(detachedHead.IsCurrentRepositoryHead);
                 Assert.False(detachedHead.IsRemote);
@@ -82,6 +106,158 @@ public void CanCheckoutAnArbitraryCommit(string commitPointer)
             }
         }
 
+        [Fact]
+        public void CheckoutAddsMissingFilesInWorkingDirectory()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                PopulateBasicRepository(repo);
+
+                // Remove the file in master branch
+                // Verify it exists after checking out otherBranch.
+                string fileFullPath = Path.Combine(repo.Info.WorkingDirectory, originalFilePath);
+                repo.Index.Remove(fileFullPath);
+                repo.Commit("2nd commit", Constants.Signature, Constants.Signature);
+
+                // Checkout other_branch
+                Branch otherBranch = repo.Branches[otherBranchName];
+                Assert.NotNull(otherBranch);
+                otherBranch.Checkout();
+
+                // Verify working directory is updated
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+                Assert.Equal(originalFileContent, File.ReadAllText(fileFullPath));
+            }
+        }
+
+        [Fact]
+        public void CheckoutRemovesExtraFilesInWorkingDirectory()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                PopulateBasicRepository(repo);
+
+                // Add extra file in master branch
+                // Verify it is removed after checking out otherBranch.
+                string newFileFullPath = Path.Combine(repo.Info.WorkingDirectory, "b.txt");
+                File.WriteAllText(newFileFullPath, "hello from master branch!\n");
+                repo.Index.Stage(newFileFullPath);
+                repo.Commit("2nd commit", Constants.Signature, Constants.Signature);
+
+                // Checkout other_branch
+                Branch otherBranch = repo.Branches[otherBranchName];
+                Assert.NotNull(otherBranch);
+                otherBranch.Checkout();
+
+                // Verify working directory is updated
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+                Assert.False(File.Exists(newFileFullPath));
+            }
+        }
+
+        [Fact]
+        public void CheckoutUpdatesModifiedFilesInWorkingDirectory()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                PopulateBasicRepository(repo);
+
+                // Modify file in master branch.
+                // Verify contents match initial commit after checking out other branch.
+                string fullPath = Path.Combine(repo.Info.WorkingDirectory, originalFilePath);
+                File.WriteAllText(fullPath, "Update : hello from master branch!\n");
+                repo.Index.Stage(fullPath);
+                repo.Commit("2nd commit", Constants.Signature, Constants.Signature);
+
+                // Checkout other_branch
+                Branch otherBranch = repo.Branches[otherBranchName];
+                Assert.NotNull(otherBranch);
+                otherBranch.Checkout();
+
+                // Verify working directory is updated
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+                Assert.Equal(originalFileContent, File.ReadAllText(fullPath));
+            }
+        }
+
+        [Fact]
+        public void CanForcefullyCheckoutWithStagedChanges()
+        {
+            TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
+
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                string fileFullPath = Path.Combine(repo.Info.WorkingDirectory, originalFilePath);
+                Branch master = repo.Branches["master"];
+                Assert.True(master.IsCurrentRepositoryHead);
+
+                // Hard reset to ensure that working directory, index, and HEAD match
+                repo.Reset(ResetOptions.Hard);
+                Assert.False(repo.Index.RetrieveStatus().IsDirty);
+
+                // Add local change
+                string fullPath = Path.Combine(repo.Info.WorkingDirectory, fileFullPath);
+                File.WriteAllText(fullPath, originalFileContent);
+                repo.Index.Stage(fullPath);
+
+                // Verify working directory is now dirty
+                Assert.True(repo.Index.RetrieveStatus().IsDirty);
+
+                // And that the new file exists
+                Assert.True(File.Exists(fileFullPath));
+
+                // Checkout with the force option
+                Branch targetBranch = repo.Branches["i-do-numbers"];
+                targetBranch.Checkout(CheckoutOptions.Force, null);
+
+                // Assert that target branch is checked out
+                Assert.True(targetBranch.IsCurrentRepositoryHead);
+
+                // And that staged change (add) is no longer preset
+                Assert.False(File.Exists(fileFullPath));
+            }
+        }
+
+        [Fact]
+        public void CheckingOutWithMergeConflictsThrows()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                string fullPath = Path.Combine(repo.Info.WorkingDirectory, "a.txt");
+                File.WriteAllText(fullPath, "Hello\n");
+                repo.Index.Stage(fullPath);
+                repo.Commit("Initial commit", Constants.Signature, Constants.Signature);
+
+                // Create 2nd branch
+                repo.CreateBranch("branch2");
+
+                // Update file in main
+                File.WriteAllText(fullPath, "Hello from master!\n");
+                repo.Index.Stage(fullPath);
+                repo.Commit("2nd commit", Constants.Signature, Constants.Signature);
+
+                // Checkout branch2
+                repo.Checkout("branch2");
+                File.WriteAllText(fullPath, "Hello From branch2!\n");
+
+                // Assert that checking out master throws
+                // when there are unstaged commits
+                Assert.Throws<MergeConflictException>(() => repo.Checkout("master"));
+
+                // And when there are staged commits
+                repo.Index.Stage(fullPath);
+                Assert.Throws<MergeConflictException>(() => repo.Checkout("master"));
+            }
+        }
+
         [Fact]
         public void CheckingOutInABareRepoThrows()
         {
@@ -111,5 +287,53 @@ public void CheckingOutABranchWithBadParamsThrows()
                 Assert.Throws<ArgumentNullException>(() => repo.Checkout(default(string)));
             }
         }
+
+        [Fact]
+        public void CheckingOutThroughBranchCallsCheckoutProgress()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                PopulateBasicRepository(repo);
+                bool wasCalled = false;
+
+                Branch branch = repo.Branches[otherBranchName];
+                branch.Checkout(CheckoutOptions.None, (path, completed, total) => wasCalled = true);
+
+                Assert.True(wasCalled);
+            }
+        }
+
+        [Fact]
+        public void CheckingOutThroughRepositoryCallsCheckoutProgress()
+        {
+            SelfCleaningDirectory scd = BuildSelfCleaningDirectory();
+
+            using (var repo = Repository.Init(scd.DirectoryPath))
+            {
+                PopulateBasicRepository(repo);
+                bool wasCalled = false;
+
+                repo.Checkout(otherBranchName, CheckoutOptions.None, (path, completed, total) => wasCalled = true);
+
+                Assert.True(wasCalled);
+            }
+        }
+
+        /// <summary>
+        ///   Helper method to populate a simple repository with
+        ///   a single file and two branches.
+        /// </summary>
+        /// <param name="repo">Repository to populate</param>
+        private void PopulateBasicRepository(Repository repo)
+        {
+            string fullPathFileA = Path.Combine(repo.Info.WorkingDirectory, "a.txt");
+            File.WriteAllText(fullPathFileA, originalFileContent);
+            repo.Index.Stage(fullPathFileA);
+            repo.Commit("Initial commit", Constants.Signature, Constants.Signature);
+
+            repo.CreateBranch(otherBranchName);
+        }
     }
 }

LibGit2Sharp.Tests/CommitFixture.cs

@@ -28,6 +28,8 @@ public void CanCorrectlyCountCommitsWhenSwitchingToAnotherBranch()
             TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
             using (var repo = new Repository(path.RepositoryPath))
             {
+                repo.Reset(ResetOptions.Hard);
+
                 repo.Checkout("test");
                 Assert.Equal(2, repo.Commits.Count());
                 Assert.Equal("e90810b8df3e80c413d903f631643c716887138d", repo.Commits.First().Id.Sha);
@@ -225,6 +227,8 @@ public void CanEnumerateFromDetachedHead()
             TemporaryCloneOfTestRepo path = BuildTemporaryCloneOfTestRepo(StandardTestRepoWorkingDirPath);
             using (var repoClone = new Repository(path.RepositoryPath))
             {
+                repoClone.Reset(ResetOptions.Hard);
+
                 string headSha = repoClone.Head.Tip.Sha;
                 repoClone.Checkout(headSha);
 

LibGit2Sharp/Branch.cs

@@ -4,6 +4,7 @@
 using LibGit2Sharp.Core;
 using LibGit2Sharp.Core.Compat;
 using LibGit2Sharp.Core.Handles;
+using LibGit2Sharp.Handlers;
 
 namespace LibGit2Sharp
 {
@@ -180,6 +181,24 @@ public virtual Remote Remote
             }
         }
 
+        /// <summary>
+        ///   Checkout this branch.
+        /// </summary>
+        public virtual void Checkout()
+        {
+            repo.CheckoutInternal(CanonicalName, CheckoutOptions.None, null);
+        }
+
+        /// <summary>
+        ///   Checkout this branch with a callback for progress reporting.
+        /// </summary>
+        /// <param name="checkoutOptions">Options controlling checkout behavior.</param>
+        /// <param name="onCheckoutProgress">Callback method to report checkout progress updates through.</param>
+        public virtual void Checkout(CheckoutOptions checkoutOptions, CheckoutProgressHandler onCheckoutProgress)
+        {
+            repo.CheckoutInternal(CanonicalName, checkoutOptions, onCheckoutProgress);
+        }
+
         private Branch ResolveTrackedBranch()
         {
             using (ReferenceSafeHandle branchPtr = repo.Refs.RetrieveReferencePtr(CanonicalName, false))