Can checkout a branch

.gitignore

@@ -26,9 +26,10 @@ Thumbs.db
 obj/
 [Rr]elease*/
 _ReSharper*/
+*.ReSharper
+*.ReSharper.user
 [Tt]est[Rr]esult*
 build/
 *.pidb
 *.userprefs
-*.swp
-%temp%
+*.swp

LibGit2Sharp.Tests/BranchFixture.cs

@@ -11,6 +11,22 @@ public class BranchFixture
     {
         private readonly List<string> expectedBranches = new List<string> {"packed-test", "packed", "br2", "master", "test"};
 
+        [Test]
+        public void CanCheckoutAnExistingBranch()
+        {
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var master = repo.Branches["master"];
+                master.IsCurrentRepositoryHead.ShouldBeTrue();
+
+                var test = repo.Branches.Checkout("test");
+
+                test.IsCurrentRepositoryHead.ShouldBeTrue();
+                master.IsCurrentRepositoryHead.ShouldBeFalse();
+            }
+        }
+
         [Test]
         public void CanCreateBranch()
         {
@@ -26,7 +42,7 @@ public void CanCreateBranch()
                 newBranch.Tip.Sha.ShouldEqual("be3563ae3f795b2b4353bcce3a527ad0a4f7f644");
                 repo.Branches.SingleOrDefault(p => p.Name == name).ShouldNotBeNull();
 
-                repo.Refs.Delete(newBranch.CanonicalName);  //TODO: To be replaced with repo.Branches.Delete(newBranch.Name)
+                repo.Refs.Delete(newBranch.CanonicalName); //TODO: To be replaced with repo.Branches.Delete(newBranch.Name)
             }
         }
 
@@ -41,11 +57,12 @@ public void CanCreateBranchFromAnotherBranch()
                 newBranch.ShouldNotBeNull();
                 newBranch.Name.ShouldEqual(name);
                 newBranch.CanonicalName.ShouldEqual("refs/heads/" + name);
+                newBranch.IsCurrentRepositoryHead.ShouldBeFalse();
                 newBranch.Tip.ShouldNotBeNull();
                 newBranch.Tip.Sha.ShouldEqual("4c062a6361ae6959e06292c1fa5e2822d9c96345");
                 repo.Branches.SingleOrDefault(p => p.Name == name).ShouldNotBeNull();
 
-                repo.Refs.Delete(newBranch.CanonicalName);  //TODO: To be replaced with repo.Branches.Delete(newBranch.Name)
+                repo.Refs.Delete(newBranch.CanonicalName); //TODO: To be replaced with repo.Branches.Delete(newBranch.Name)
             }
         }
 
@@ -63,20 +80,6 @@ public void CanListAllBranches()
             }
         }
 
-        [Test]
-        public void CanLookupLocalBranch()
-        {
-            using (var repo = new Repository(Constants.TestRepoPath))
-            {
-                var master = repo.Branches["master"];
-                master.ShouldNotBeNull();
-                master.IsRemote.ShouldBeFalse();
-                master.Name.ShouldEqual("master");
-                master.CanonicalName.ShouldEqual("refs/heads/master");
-                master.Tip.Sha.ShouldEqual("4c062a6361ae6959e06292c1fa5e2822d9c96345");
-            }
-        }
-
         [Test]
         public void CanLookupABranchByItsCanonicalName()
         {
@@ -95,6 +98,21 @@ public void CanLookupABranchByItsCanonicalName()
             }
         }
 
+        [Test]
+        public void CanLookupLocalBranch()
+        {
+            using (var repo = new Repository(Constants.TestRepoPath))
+            {
+                var master = repo.Branches["master"];
+                master.ShouldNotBeNull();
+                master.IsRemote.ShouldBeFalse();
+                master.Name.ShouldEqual("master");
+                master.CanonicalName.ShouldEqual("refs/heads/master");
+                master.IsCurrentRepositoryHead.ShouldBeTrue();
+                master.Tip.Sha.ShouldEqual("4c062a6361ae6959e06292c1fa5e2822d9c96345");
+            }
+        }
+
         [Test]
         public void CanWalkCommitsFromAnotherBranch()
         {
@@ -115,6 +133,17 @@ public void CanWalkCommitsFromBranch()
             }
         }
 
+        [Test]
+        public void CheckoutBranchWithBadParamsThrows()
+        {
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                Assert.Throws<ArgumentException>(() => repo.Branches.Checkout(string.Empty));
+                Assert.Throws<ArgumentNullException>(() => repo.Branches.Checkout(null));
+            }
+        }
+
         [Test]
         public void CreatingBranchWithEmptyNameThrows()
         {
@@ -151,5 +180,47 @@ public void CreatingBranchWithNullTargetThrows()
                 Assert.Throws<ArgumentNullException>(() => repo.Branches.Create("bad_branch", (ObjectId) null));
             }
         }
+
+        [Test]
+        public void OnlyOneBranchIsTheHead()
+        {
+            using (var repo = new Repository(Constants.TestRepoPath))
+            {
+                Branch head = null;
+
+                foreach (var branch in repo.Branches)
+                {
+                    bool isHead = branch.IsCurrentRepositoryHead;
+
+                    if (!isHead)
+                    {
+                        continue;
+                    }
+
+                    if (head == null)
+                    {
+                        head = branch;
+                        continue;
+                    }
+
+                    Assert.Fail("Both '{0}' and '{1}' appear to be Head.", head.CanonicalName, branch.CanonicalName);
+                }
+
+                head.ShouldNotBeNull();
+            }
+        }
+
+        [Test]
+        public void TwoBranchesPointingAtTheSameCommitAreNotBothCurrent()
+        {
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var master = repo.Branches["refs/heads/master"];
+
+                var newBranch = repo.Branches.Create("clone-of-master", master.Tip.Sha);
+                newBranch.IsCurrentRepositoryHead.ShouldBeFalse();
+            }
+        }
     }
 }

LibGit2Sharp.Tests/ReferenceFixture.cs

@@ -9,7 +9,7 @@ namespace LibGit2Sharp.Tests
     [TestFixture]
     public class ReferenceFixture
     {
-        private readonly List<string> expectedRefs = new List<string> { "refs/heads/packed-test", "refs/heads/packed", "refs/heads/br2", "refs/heads/master", "refs/heads/test", "refs/tags/test", "refs/tags/e90810b", "refs/tags/lw" };
+        private readonly List<string> expectedRefs = new List<string> {"refs/heads/packed-test", "refs/heads/packed", "refs/heads/br2", "refs/heads/master", "refs/heads/test", "refs/tags/test", "refs/tags/e90810b", "refs/tags/lw"};
 
         [Test]
         public void CanCreateReferenceFromSha()
@@ -40,32 +40,13 @@ public void CanCreateReferenceFromSymbol()
                 newRef.ShouldNotBeNull();
                 newRef.CanonicalName.ShouldEqual(name);
                 newRef.Target.ShouldNotBeNull();
-                ((DirectReference)newRef.Target).Target.Sha.ShouldEqual("4c062a6361ae6959e06292c1fa5e2822d9c96345");
+                ((DirectReference) newRef.Target).Target.Sha.ShouldEqual("4c062a6361ae6959e06292c1fa5e2822d9c96345");
                 repo.Refs.SingleOrDefault(p => p.CanonicalName == name).ShouldNotBeNull();
 
                 repo.Refs.Delete(newRef.CanonicalName);
             }
         }
 
-        [Test]
-        public void DeleteWithNullNameThrows()
-        {
-            using (var repo = new Repository(Constants.TestRepoPath))
-            {
-                Assert.Throws<ArgumentNullException>(() => repo.Refs.Delete(null));
-            }
-        }
-
-        [Test]
-        public void DeleteWithEmptyNameThrows()
-        {
-            using (var repo = new Repository(Constants.TestRepoPath))
-            {
-                Assert.Throws<ArgumentException>(() => repo.Refs.Delete(string.Empty));
-            }
-        }
-
-
         [Test]
         public void CanListAllReferences()
         {
@@ -90,7 +71,7 @@ public void CanResolveHeadByName()
                 head.CanonicalName.ShouldEqual("HEAD");
                 head.Target.ShouldNotBeNull();
                 head.Target.CanonicalName.ShouldEqual("refs/heads/master");
-                ((DirectReference)head.Target).Target.Sha.ShouldEqual("4c062a6361ae6959e06292c1fa5e2822d9c96345");
+                ((DirectReference) head.Target).Target.Sha.ShouldEqual("4c062a6361ae6959e06292c1fa5e2822d9c96345");
                 Assert.IsInstanceOf<Commit>(((DirectReference) head.Target).Target);
 
                 var head2 = (SymbolicReference) repo.Refs.Head;
@@ -103,30 +84,30 @@ public void CanResolveHeadByName()
         }
 
         [Test]
-        public void CanResolveReferenceToAnAnnotatedTag()
+        public void CanResolveReferenceToALightweightTag()
         {
             using (var repo = new Repository(Constants.TestRepoPath))
             {
-                var annTag = (DirectReference)repo.Refs["refs/tags/test"];
-                annTag.ShouldNotBeNull();
-                annTag.CanonicalName.ShouldEqual("refs/tags/test");
-                annTag.Target.ShouldNotBeNull();
-                annTag.Target.Sha.ShouldEqual("b25fa35b38051e4ae45d4222e795f9df2e43f1d1");
-                Assert.IsInstanceOf<TagAnnotation>(annTag.Target);
+                var lwTag = (DirectReference) repo.Refs["refs/tags/lw"];
+                lwTag.ShouldNotBeNull();
+                lwTag.CanonicalName.ShouldEqual("refs/tags/lw");
+                lwTag.Target.ShouldNotBeNull();
+                lwTag.Target.Sha.ShouldEqual("e90810b8df3e80c413d903f631643c716887138d");
+                Assert.IsInstanceOf<Commit>(lwTag.Target);
             }
         }
 
         [Test]
-        public void CanResolveReferenceToALightweightTag()
+        public void CanResolveReferenceToAnAnnotatedTag()
         {
             using (var repo = new Repository(Constants.TestRepoPath))
             {
-                var lwTag = (DirectReference)repo.Refs["refs/tags/lw"];
-                lwTag.ShouldNotBeNull();
-                lwTag.CanonicalName.ShouldEqual("refs/tags/lw");
-                lwTag.Target.ShouldNotBeNull();
-                lwTag.Target.Sha.ShouldEqual("e90810b8df3e80c413d903f631643c716887138d");
-                Assert.IsInstanceOf<Commit>(lwTag.Target);
+                var annTag = (DirectReference) repo.Refs["refs/tags/test"];
+                annTag.ShouldNotBeNull();
+                annTag.CanonicalName.ShouldEqual("refs/tags/test");
+                annTag.Target.ShouldNotBeNull();
+                annTag.Target.Sha.ShouldEqual("b25fa35b38051e4ae45d4222e795f9df2e43f1d1");
+                Assert.IsInstanceOf<TagAnnotation>(annTag.Target);
             }
         }
 
@@ -144,6 +125,43 @@ public void CanResolveRefsByName()
             }
         }
 
+        [Test]
+        public void CanUpdateTargetOnReference()
+        {
+            const string masterRef = "refs/heads/master";
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var sha = repo.Refs["refs/heads/test"].ResolveToDirectReference().Target.Sha;
+                var master = repo.Refs[masterRef];
+                master.ResolveToDirectReference().Target.Sha.ShouldNotEqual(sha);
+
+                repo.Refs.UpdateTarget(masterRef, sha);
+
+                master = repo.Refs[masterRef];
+                master.ResolveToDirectReference().Target.Sha.ShouldEqual(sha);
+            }
+        }
+
+        [Test]
+        public void CanUpdateTargetOnSymolicReference()
+        {
+            const string name = "refs/heads/unit_test";
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var newRef = (SymbolicReference) repo.Refs.Create(name, "refs/heads/master");
+                newRef.ShouldNotBeNull();
+
+                repo.Refs.UpdateTarget(newRef.CanonicalName, "refs/heads/test");
+
+                newRef = (SymbolicReference) repo.Refs[newRef.CanonicalName];
+                newRef.ResolveToDirectReference().Target.ShouldEqual(repo.Refs["refs/heads/test"].ResolveToDirectReference().Target);
+
+                repo.Refs.Delete(newRef.CanonicalName);
+            }
+        }
+
         [Test]
         public void CreateWithEmptyStringForTargetThrows()
         {
@@ -170,7 +188,7 @@ public void CreateWithNullForTargetThrows()
             using (var path = new TemporaryCloneOfTestRepo())
             using (var repo = new Repository(path.RepositoryPath))
             {
-                Assert.Throws<ArgumentNullException>(() => repo.Refs.Create("refs/heads/newref", (string)null));
+                Assert.Throws<ArgumentNullException>(() => repo.Refs.Create("refs/heads/newref", (string) null));
             }
         }
 
@@ -184,6 +202,24 @@ public void CreateWithNullStringThrows()
             }
         }
 
+        [Test]
+        public void DeleteWithEmptyNameThrows()
+        {
+            using (var repo = new Repository(Constants.TestRepoPath))
+            {
+                Assert.Throws<ArgumentException>(() => repo.Refs.Delete(string.Empty));
+            }
+        }
+
+        [Test]
+        public void DeleteWithNullNameThrows()
+        {
+            using (var repo = new Repository(Constants.TestRepoPath))
+            {
+                Assert.Throws<ArgumentNullException>(() => repo.Refs.Delete(null));
+            }
+        }
+
         [Test]
         public void ResolvingWithEmptyStringThrows()
         {
@@ -201,5 +237,46 @@ public void ResolvingWithNullThrows()
                 Assert.Throws<ArgumentNullException>(() => { var head = repo.Refs[null]; });
             }
         }
+
+        [Test]
+        public void TryingToUpdateADirectRefWithSymbolFails()
+        {
+            const string name = "refs/heads/unit_test";
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                var newRef = (SymbolicReference) repo.Refs.Create(name, "refs/heads/master");
+                newRef.ShouldNotBeNull();
+
+                Assert.Throws<ArgumentException>(
+                    () => repo.Refs.UpdateTarget(newRef.CanonicalName, repo.Refs["refs/heads/test"].ResolveToDirectReference().Target.Sha));
+
+                repo.Refs.Delete(newRef.CanonicalName);
+            }
+        }
+
+        [Test]
+        public void TryingToUpdateASymbolicRefWithOidFails()
+        {
+            const string masterRef = "refs/heads/master";
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                Assert.Throws<ArgumentException>(() => repo.Refs.UpdateTarget(masterRef, "refs/heads/test"));
+            }
+        }
+
+        [Test]
+        public void UpdateReferenceTargetWithBadParametersFails()
+        {
+            using (var path = new TemporaryCloneOfTestRepo())
+            using (var repo = new Repository(path.RepositoryPath))
+            {
+                Assert.Throws<ArgumentException>(() => repo.Refs.UpdateTarget(string.Empty, "refs/heads/packed"));
+                Assert.Throws<ArgumentException>(() => repo.Refs.UpdateTarget("master", string.Empty));
+                Assert.Throws<ArgumentNullException>(() => repo.Refs.UpdateTarget(null, "refs/heads/packed"));
+                Assert.Throws<ArgumentNullException>(() => repo.Refs.UpdateTarget("master", null));
+            }
+        }
     }
 }