Branch.Remote property should not throw

The Branch.Remote property can throw when it attempts to resolve a remote
for a remote-tracking branch, and the remote cannot be found or is
ambiguous. In those situations, Branch.Remote should return null. If there
is a need for the specific exception to be returned, we can look at
transitioning to a method for this functionality.

Author: jamill

LibGit2Sharp.Tests/BranchFixture.cs

@@ -391,6 +391,64 @@ public void QueryUpstreamBranchCanonicalNameForLocalTrackingBranch()
             }
         }
 
+        [Fact]
+        public void QueryRemoteForRemoteBranch()
+        {
+            using (var repo = new Repository(StandardTestRepoPath))
+            {
+                var master = repo.Branches["origin/master"];
+                Assert.Equal(repo.Network.Remotes["origin"], master.Remote);
+            }
+        }
+
+        [Fact]
+        public void QueryUnresolvableRemoteForRemoteBranch()
+        {
+            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.Null(branch.Remote);
+            }
+        }
+
+        [Fact]
+        public void QueryAmbigousRemoteForRemoteBranch()
+        {
+            var path = CloneStandardTestRepo();
+
+            var fetchRefSpec = "+refs/heads/*:refs/remotes/origin/*";
+            var url = "http://github.com/libgit2/TestGitRepository";
+
+            using (var repo = InitIsolatedRepository(path))
+            {
+                // Add a second remote so that it is ambiguous which remote
+                // the remote-tracking branch tracks.
+                repo.Network.Remotes.Add("ambiguous", url, fetchRefSpec);
+
+                Branch branch = repo.Branches["refs/remotes/origin/master"];
+
+                Assert.NotNull(branch);
+                Assert.True(branch.IsRemote);
+
+                Assert.Null(branch.Remote);
+            }
+        }
+
         [Fact]
         public void CanLookupABranchByItsCanonicalName()
         {

LibGit2Sharp/Branch.cs

@@ -149,7 +149,13 @@ public virtual string UpstreamBranchCanonicalName
         }
 
         /// <summary>
-        /// Gets the configured <see cref="Remote"/> to fetch from and push to.
+        /// Get the remote for the branch.
+        /// <para>
+        ///   If this is a local branch, this will return 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>
         /// </summary>
         public virtual Remote Remote
         {
@@ -164,11 +170,11 @@ public virtual Remote Remote
                 else
                 {
                     remoteName = RemoteNameFromLocalBranch();
+                }
 
-                    if (remoteName == null)
-                    {
-                        return null;
-                    }
+                if (remoteName == null)
+                {
+                    return null;
                 }
 
                 return repo.Network.Remotes[remoteName];
@@ -210,7 +216,7 @@ private string RemoteNameFromLocalBranch()
 
         private string RemoteNameFromRemoteTrackingBranch()
         {
-            return Proxy.git_branch_remote_name(repo.Handle, CanonicalName);
+            return Proxy.git_branch_remote_name(repo.Handle, CanonicalName, false);
         }
 
         /// <summary>

LibGit2Sharp/BranchUpdater.cs

@@ -181,7 +181,7 @@ private void GetUpstreamInformation(string canonicalName, out string remoteName,
             }
             else if (canonicalName.LooksLikeRemoteTrackingBranch())
             {
-                remoteName = Proxy.git_branch_remote_name(repo.Handle, canonicalName);
+                remoteName = Proxy.git_branch_remote_name(repo.Handle, canonicalName, true);
 
                 Remote remote = repo.Network.Remotes.RemoteForName(remoteName);
                 mergeBranchName = remote.FetchSpecTransformToSource(canonicalName);

LibGit2Sharp/Core/Proxy.cs

@@ -203,15 +203,21 @@ public static ReferenceSafeHandle git_branch_move(ReferenceSafeHandle reference,
             }
         }
 
-        public static string git_branch_remote_name(RepositorySafeHandle repo, string canonical_branch_name)
+        public static string git_branch_remote_name(RepositorySafeHandle repo, string canonical_branch_name, bool shouldThrowIfNotFound)
         {
             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;
+                if (!shouldThrowIfNotFound &&
+                    (res == (int) GitErrorCode.NotFound || res == (int) GitErrorCode.Ambiguous))
+                {
+                    return null;
+                }
+
+                Ensure.ZeroResult(res);
+                return LaxUtf8Marshaler.FromNative(buf.ptr);
             }
         }