Teach Branch to get a remote-tracking branch's remote.

The logic to get the remote of a tracked branch has more failure cases
then getting the configured remote for a local branch. This functionality
should be in its own function and return exceptions.

Author: jamill

LibGit2Sharp.Tests/BranchFixture.cs

@@ -391,6 +391,72 @@ public void QueryUpstreamBranchCanonicalNameForLocalTrackingBranch()
             }
         }
 
+        [Fact]
+        public void CanGetRemoteForLocalBranch()
+        {
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                Branch master = repo.Branches["master"];
+                Assert.Equal(repo.Network.Remotes["origin"], master.GetTrackedRemote());
+            }
+        }
+
+        [Fact]
+        public void CanGetRemoteForRemoteBranch()
+        {
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                Branch master = repo.Branches["origin/master"];
+                Assert.Equal(repo.Network.Remotes["origin"], master.GetTrackedRemote());
+            }
+        }
+
+        [Fact]
+        public void GettingUnresolvableRemoteThrows()
+        {
+            var path = CloneStandardTestRepo();
+
+            var fetchRefSpecs = new string[] { "+refs/heads/notfound/*:refs/remotes/origin/notfound/*" };
+
+            using (var repo = InitIsolatedRepository(path))
+            {
+                // Update the remote config such that the remote for a
+                // remote branch cannot be resolved
+                Remote remote = repo.Network.Remotes["origin"];
+                Assert.NotNull(remote);
+
+                repo.Network.Remotes.Update(remote, r => r.FetchRefSpecs = fetchRefSpecs);
+
+                Branch branch = repo.Branches["refs/remotes/origin/master"];
+
+                Assert.NotNull(branch);
+                Assert.True(branch.IsRemote);
+
+                Assert.Throws<LibGit2SharpException>(() => branch.GetTrackedRemote());
+            }
+        }
+
+        [Fact]
+        public void GettingAmbigousTrackedRemoteThrows()
+        {
+            var path = CloneStandardTestRepo();
+
+            var fetchRefSpec = "+refs/heads/*:refs/remotes/origin/*";
+            var url = "http://github.com/libgit2/TestGitRepository";
+
+            using (var repo = InitIsolatedRepository(path))
+            {
+                repo.Network.Remotes.Add("ambiguous", url, fetchRefSpec);
+
+                Branch branch = repo.Branches["refs/remotes/origin/master"];
+
+                Assert.NotNull(branch);
+                Assert.True(branch.IsRemote);
+
+                Assert.Throws<LibGit2SharpException>(() => branch.GetTrackedRemote());
+            }
+        }
+
         [Fact]
         public void CanLookupABranchByItsCanonicalName()
         {
@@ -990,7 +1056,7 @@ public void RemoteBranchesDoNotTrackAnything()
                 foreach (var branch in branches)
                 {
                     Assert.True(branch.IsRemote);
-                    Assert.NotNull(branch.Remote);
+                    Assert.Null(branch.Remote);
                     Assert.False(branch.IsTracking);
                     Assert.Null(branch.TrackedBranch);
 

LibGit2Sharp/Branch.cs

@@ -155,26 +155,48 @@ public virtual Remote Remote
         {
             get
             {
-                string remoteName;
+                string remoteName = null;
 
-                if (IsRemote)
-                {
-                    remoteName = RemoteNameFromRemoteTrackingBranch();
-                }
-                else
+                if (!IsRemote)
                 {
                     remoteName = RemoteNameFromLocalBranch();
+                }
 
-                    if (remoteName == null)
-                    {
-                        return null;
-                    }
+                if (remoteName == null)
+                {
+                    return null;
                 }
 
                 return repo.Network.Remotes[remoteName];
             }
         }
 
+        /// <summary>
+        /// Get the <see cref="Remote"/> of the branch that this branch tracks.
+        /// <para>
+        ///   If this is a local branch, this will return the the configured
+        ///   <see cref="Remote"/> to fetch from and push to. If this is a
+        ///   remote-tracking branch, this will return the remote containing
+        ///   the tracked branch.
+        /// </para>
+        /// <para>
+        ///   This will throw an exception if there is an error resolving the
+        ///   remote for this branch. If this is a local only branch, then
+        ///   this will return null.
+        /// </para>
+        /// </summary>
+        /// <returns>The remote of the tracked branch or null if this is a local branch.</returns>
+        public virtual Remote GetTrackedRemote()
+        {
+            if (!IsRemote)
+            {
+                return this.Remote;
+            }
+
+            var remoteName = RemoteNameFromRemoteTrackingBranch();
+            return repo.Network.Remotes.RemoteForName(remoteName, true);
+        }
+
         private string UpstreamBranchCanonicalNameFromLocalBranch()
         {
             ConfigurationEntry<string> mergeRefEntry = repo.Config.Get<string>("branch", Name, "merge");

LibGit2Sharp/Core/Proxy.cs

@@ -203,15 +203,22 @@ public static ReferenceSafeHandle git_branch_move(ReferenceSafeHandle reference,
             }
         }
 
+        /// <summary>
+        /// Call into libgit2 to get the remote name that a remote tracking branch
+        /// tracks. Throws an exception if the remote name cannot be resolved.
+        /// </summary>
+        /// <param name="repo"></param>
+        /// <param name="canonical_branch_name"></param>
+        /// <returns>The name of the remote that the branch tracks.</returns>
         public static string git_branch_remote_name(RepositorySafeHandle repo, string canonical_branch_name)
         {
             using (ThreadAffinity())
             using (var buf = new GitBuf())
             {
                 int res = NativeMethods.git_branch_remote_name(buf, repo, canonical_branch_name);
-                Ensure.Int32Result(res);
 
-                return LaxUtf8Marshaler.FromNative(buf.ptr) ?? string.Empty;
+                Ensure.ZeroResult(res);
+                return LaxUtf8Marshaler.FromNative(buf.ptr);
             }
         }