Throw more meaningful NotFoundException when appropriate

jamill · nulltoken · commit 23f97d95d212 · 2015-01-21T12:20:18.000+01:00
This change is to throw more specific exceptions in several cases when
possible. If an object cannot be found, throw a more specific
NotFoundException.
diff --git a/LibGit2Sharp.Tests/BlameFixture.cs b/LibGit2Sharp.Tests/BlameFixture.cs
@@ -36,7 +36,7 @@ public void CanBlameFromADifferentCommit()
             using (var repo = new Repository(path))
             {
                 // File doesn't exist at HEAD
-                Assert.Throws<LibGit2SharpException>(() => repo.Blame("ancestor-only.txt"));
+                Assert.Throws<NotFoundException>(() => repo.Blame("ancestor-only.txt"));
 
                 var blame = repo.Blame("ancestor-only.txt", new BlameOptions { StartingAt = "9107b30" });
                 Assert.Equal(1, blame.Count());
diff --git a/LibGit2Sharp.Tests/BranchFixture.cs b/LibGit2Sharp.Tests/BranchFixture.cs
@@ -254,7 +254,7 @@ public void CreatingBranchWithUnknownNamedTargetThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));
+                Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));
             }
         }
 
@@ -264,8 +264,8 @@ public void CreatingBranchWithUnknownShaTargetThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));
-                Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));
+                Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));
+                Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));
             }
         }
 
@@ -729,7 +729,7 @@ public void SetTrackedBranchForUnreasolvableRemoteThrows()
 
                 Branch trackedBranch = repo.Branches[trackedBranchName];
 
-                Assert.Throws<LibGit2SharpException>(() => repo.Branches.Update(branch,
+                Assert.Throws<NotFoundException>(() => repo.Branches.Update(branch,
                                                                                 b => b.TrackedBranch = trackedBranch.CanonicalName));
             }
         }
diff --git a/LibGit2Sharp.Tests/CheckoutFixture.cs b/LibGit2Sharp.Tests/CheckoutFixture.cs
@@ -383,7 +383,7 @@ public void CheckingOutANonExistingBranchThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Checkout("i-do-not-exist"));
+                Assert.Throws<NotFoundException>(() => repo.Checkout("i-do-not-exist"));
             }
         }
 
@@ -895,7 +895,7 @@ public void CheckoutLowerCasedHeadThrows()
             string path = SandboxStandardTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Checkout("head"));
+                Assert.Throws<NotFoundException>(() => repo.Checkout("head"));
             }
         }
 
diff --git a/LibGit2Sharp.Tests/CommitFixture.cs b/LibGit2Sharp.Tests/CommitFixture.cs
@@ -107,8 +107,8 @@ public void QueryingTheCommitHistoryWithUnknownShaOrInvalidEntryPointThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());
-                Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());
+                Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());
+                Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());
                 Assert.Throws<ArgumentNullException>(() => repo.Commits.QueryBy(new CommitFilter { Since = null }).Count());
             }
         }
@@ -121,8 +121,8 @@ public void QueryingTheCommitHistoryFromACorruptedReferenceThrows()
             {
                 CreateCorruptedDeadBeefHead(repo.Info.Path);
 
-                Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());
-                Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());
+                Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());
+                Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());
             }
         }
 
diff --git a/LibGit2Sharp.Tests/ReferenceFixture.cs b/LibGit2Sharp.Tests/ReferenceFixture.cs
@@ -73,7 +73,7 @@ public void CreatingADirectReferenceWithARevparseSpecPointingAtAnUnknownObjectFa
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Refs.Add(name, "master^42"));
+                Assert.Throws<NotFoundException>(() => repo.Refs.Add(name, "master^42"));
             }
         }
 
@@ -610,7 +610,7 @@ public void UpdatingADirectReferenceTargetWithARevparsePointingAtAnUnknownObject
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));
+                Assert.Throws<NotFoundException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));
             }
         }
 
diff --git a/LibGit2Sharp.Tests/ResetHeadFixture.cs b/LibGit2Sharp.Tests/ResetHeadFixture.cs
@@ -71,7 +71,7 @@ public void ResettingWithBadParamsThrows()
                 Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (string)null));
                 Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (Commit)null));
                 Assert.Throws<ArgumentException>(() => repo.Reset(ResetMode.Soft, ""));
-                Assert.Throws<LibGit2SharpException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));
+                Assert.Throws<NotFoundException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));
                 Assert.Throws<InvalidSpecificationException>(() => repo.Reset(ResetMode.Soft, repo.Head.Tip.Tree.Sha));
             }
         }
diff --git a/LibGit2Sharp.Tests/TagFixture.cs b/LibGit2Sharp.Tests/TagFixture.cs
@@ -258,7 +258,7 @@ public void CreatingATagForAnUnknowReferenceThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));
+                Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));
             }
         }
 
@@ -269,7 +269,7 @@ public void CreatingATagForAnUnknowObjectIdThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));
+                Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));
             }
         }
 
@@ -507,7 +507,7 @@ public void AddTagWithNotExistingTargetThrows()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));
+                Assert.Throws<NotFoundException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));
             }
         }
 
@@ -623,7 +623,7 @@ public void RemovingAnUnknownTagShouldFail()
             string path = SandboxBareTestRepo();
             using (var repo = new Repository(path))
             {
-                Assert.Throws<LibGit2SharpException>(() => repo.Tags.Remove("unknown-tag"));
+                Assert.Throws<NotFoundException>(() => repo.Tags.Remove("unknown-tag"));
             }
         }
 
diff --git a/LibGit2Sharp/Core/Ensure.cs b/LibGit2Sharp/Core/Ensure.cs
@@ -100,6 +100,7 @@ private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCode, GitE
                     { GitErrorCode.NonFastForward, (m, r, c) => new NonFastForwardException(m, r, c) },
                     { GitErrorCode.MergeConflict, (m, r, c) => new MergeConflictException(m, r, c) },
                     { GitErrorCode.LockedFile, (m, r, c) => new LockedFileException(m, r, c) },
+                    { GitErrorCode.NotFound, (m, r, c) => new NotFoundException(m, r, c) },
                 };
 
         private static void HandleError(int result)
@@ -215,7 +216,7 @@ public static void GitObjectIsNotNull(GitObject gitObject, string identifier)
             }
             else
             {
-                exceptionBuilder = m => new LibGit2SharpException(m);
+                exceptionBuilder = m => new NotFoundException(m);
             }
 
             GitObjectIsNotNull(gitObject, identifier, exceptionBuilder);

Original file line number	Diff line number	Diff line change
`@@ -36,7 +36,7 @@ public void CanBlameFromADifferentCommit()`
`36`	`36`	`using (var repo = new Repository(path))`
`37`	`37`	`{`
`38`	`38`	`// File doesn't exist at HEAD`
`39`		`- Assert.Throws<LibGit2SharpException>(() => repo.Blame("ancestor-only.txt"));`
	`39`	`+ Assert.Throws<NotFoundException>(() => repo.Blame("ancestor-only.txt"));`
`40`	`40`
`41`	`41`	`var blame = repo.Blame("ancestor-only.txt", new BlameOptions { StartingAt = "9107b30" });`
`42`	`42`	`Assert.Equal(1, blame.Count());`
Original file line number	Diff line number	Diff line change
`@@ -254,7 +254,7 @@ public void CreatingBranchWithUnknownNamedTargetThrows()`
`254`	`254`	`string path = SandboxBareTestRepo();`
`255`	`255`	`using (var repo = new Repository(path))`
`256`	`256`	`{`
`257`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));`
	`257`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", "my_old_branch"));`
`258`	`258`	`}`
`259`	`259`	`}`
`260`	`260`
`@@ -264,8 +264,8 @@ public void CreatingBranchWithUnknownShaTargetThrows()`
`264`	`264`	`string path = SandboxBareTestRepo();`
`265`	`265`	`using (var repo = new Repository(path))`
`266`	`266`	`{`
`267`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));`
`268`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));`
	`267`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha));`
	`268`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Add("my_new_branch", Constants.UnknownSha.Substring(0, 7)));`
`269`	`269`	`}`
`270`	`270`	`}`
`271`	`271`
`@@ -729,7 +729,7 @@ public void SetTrackedBranchForUnreasolvableRemoteThrows()`
`729`	`729`
`730`	`730`	`Branch trackedBranch = repo.Branches[trackedBranchName];`
`731`	`731`
`732`		`- Assert.Throws<LibGit2SharpException>(() => repo.Branches.Update(branch,`
	`732`	`+ Assert.Throws<NotFoundException>(() => repo.Branches.Update(branch,`
`733`	`733`	`b => b.TrackedBranch = trackedBranch.CanonicalName));`
`734`	`734`	`}`
`735`	`735`	`}`
Original file line number	Diff line number	Diff line change
`@@ -383,7 +383,7 @@ public void CheckingOutANonExistingBranchThrows()`
`383`	`383`	`string path = SandboxBareTestRepo();`
`384`	`384`	`using (var repo = new Repository(path))`
`385`	`385`	`{`
`386`		`- Assert.Throws<LibGit2SharpException>(() => repo.Checkout("i-do-not-exist"));`
	`386`	`+ Assert.Throws<NotFoundException>(() => repo.Checkout("i-do-not-exist"));`
`387`	`387`	`}`
`388`	`388`	`}`
`389`	`389`
`@@ -895,7 +895,7 @@ public void CheckoutLowerCasedHeadThrows()`
`895`	`895`	`string path = SandboxStandardTestRepo();`
`896`	`896`	`using (var repo = new Repository(path))`
`897`	`897`	`{`
`898`		`- Assert.Throws<LibGit2SharpException>(() => repo.Checkout("head"));`
	`898`	`+ Assert.Throws<NotFoundException>(() => repo.Checkout("head"));`
`899`	`899`	`}`
`900`	`900`	`}`
`901`	`901`
Original file line number	Diff line number	Diff line change
`@@ -107,8 +107,8 @@ public void QueryingTheCommitHistoryWithUnknownShaOrInvalidEntryPointThrows()`
`107`	`107`	`string path = SandboxBareTestRepo();`
`108`	`108`	`using (var repo = new Repository(path))`
`109`	`109`	`{`
`110`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());`
`111`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());`
	`110`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = Constants.UnknownSha }).Count());`
	`111`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = "refs/heads/deadbeef" }).Count());`
`112`	`112`	`Assert.Throws<ArgumentNullException>(() => repo.Commits.QueryBy(new CommitFilter { Since = null }).Count());`
`113`	`113`	`}`
`114`	`114`	`}`
`@@ -121,8 +121,8 @@ public void QueryingTheCommitHistoryFromACorruptedReferenceThrows()`
`121`	`121`	`{`
`122`	`122`	`CreateCorruptedDeadBeefHead(repo.Info.Path);`
`123`	`123`
`124`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());`
`125`		`- Assert.Throws<LibGit2SharpException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());`
	`124`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Branches["deadbeef"] }).Count());`
	`125`	`+ Assert.Throws<NotFoundException>(() => repo.Commits.QueryBy(new CommitFilter { Since = repo.Refs["refs/heads/deadbeef"] }).Count());`
`126`	`126`	`}`
`127`	`127`	`}`
`128`	`128`
Original file line number	Diff line number	Diff line change
`@@ -73,7 +73,7 @@ public void CreatingADirectReferenceWithARevparseSpecPointingAtAnUnknownObjectFa`
`73`	`73`	`string path = SandboxBareTestRepo();`
`74`	`74`	`using (var repo = new Repository(path))`
`75`	`75`	`{`
`76`		`- Assert.Throws<LibGit2SharpException>(() => repo.Refs.Add(name, "master^42"));`
	`76`	`+ Assert.Throws<NotFoundException>(() => repo.Refs.Add(name, "master^42"));`
`77`	`77`	`}`
`78`	`78`	`}`
`79`	`79`
`@@ -610,7 +610,7 @@ public void UpdatingADirectReferenceTargetWithARevparsePointingAtAnUnknownObject`
`610`	`610`	`string path = SandboxBareTestRepo();`
`611`	`611`	`using (var repo = new Repository(path))`
`612`	`612`	`{`
`613`		`- Assert.Throws<LibGit2SharpException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));`
	`613`	`+ Assert.Throws<NotFoundException>(() => repo.Refs.UpdateTarget(repo.Refs["refs/heads/master"], "refs/heads/nope"));`
`614`	`614`	`}`
`615`	`615`	`}`
`616`	`616`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ public void ResettingWithBadParamsThrows()`
`71`	`71`	`Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (string)null));`
`72`	`72`	`Assert.Throws<ArgumentNullException>(() => repo.Reset(ResetMode.Soft, (Commit)null));`
`73`	`73`	`Assert.Throws<ArgumentException>(() => repo.Reset(ResetMode.Soft, ""));`
`74`		`- Assert.Throws<LibGit2SharpException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));`
	`74`	`+ Assert.Throws<NotFoundException>(() => repo.Reset(ResetMode.Soft, Constants.UnknownSha));`
`75`	`75`	`Assert.Throws<InvalidSpecificationException>(() => repo.Reset(ResetMode.Soft, repo.Head.Tip.Tree.Sha));`
`76`	`76`	`}`
`77`	`77`	`}`
Original file line number	Diff line number	Diff line change
`@@ -258,7 +258,7 @@ public void CreatingATagForAnUnknowReferenceThrows()`
`258`	`258`	`string path = SandboxBareTestRepo();`
`259`	`259`	`using (var repo = new Repository(path))`
`260`	`260`	`{`
`261`		`- Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));`
	`261`	`+ Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", "aaaaaaaaaaa"));`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`
`@@ -269,7 +269,7 @@ public void CreatingATagForAnUnknowObjectIdThrows()`
`269`	`269`	`string path = SandboxBareTestRepo();`
`270`	`270`	`using (var repo = new Repository(path))`
`271`	`271`	`{`
`272`		`- Assert.Throws<LibGit2SharpException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));`
	`272`	`+ Assert.Throws<NotFoundException>(() => repo.ApplyTag("mytagnorev", Constants.UnknownSha));`
`273`	`273`	`}`
`274`	`274`	`}`
`275`	`275`
`@@ -507,7 +507,7 @@ public void AddTagWithNotExistingTargetThrows()`
`507`	`507`	`string path = SandboxBareTestRepo();`
`508`	`508`	`using (var repo = new Repository(path))`
`509`	`509`	`{`
`510`		`- Assert.Throws<LibGit2SharpException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));`
	`510`	`+ Assert.Throws<NotFoundException>(() => repo.Tags.Add("test_tag", Constants.UnknownSha, signatureTim, "message"));`
`511`	`511`	`}`
`512`	`512`	`}`
`513`	`513`
`@@ -623,7 +623,7 @@ public void RemovingAnUnknownTagShouldFail()`
`623`	`623`	`string path = SandboxBareTestRepo();`
`624`	`624`	`using (var repo = new Repository(path))`
`625`	`625`	`{`
`626`		`- Assert.Throws<LibGit2SharpException>(() => repo.Tags.Remove("unknown-tag"));`
	`626`	`+ Assert.Throws<NotFoundException>(() => repo.Tags.Remove("unknown-tag"));`
`627`	`627`	`}`
`628`	`628`	`}`
`629`	`629`
Original file line number	Diff line number	Diff line change
`@@ -100,6 +100,7 @@ private static readonly Dictionary<GitErrorCode, Func<string, GitErrorCode, GitE`
`100`	`100`	`{ GitErrorCode.NonFastForward, (m, r, c) => new NonFastForwardException(m, r, c) },`
`101`	`101`	`{ GitErrorCode.MergeConflict, (m, r, c) => new MergeConflictException(m, r, c) },`
`102`	`102`	`{ GitErrorCode.LockedFile, (m, r, c) => new LockedFileException(m, r, c) },`
	`103`	`+ { GitErrorCode.NotFound, (m, r, c) => new NotFoundException(m, r, c) },`
`103`	`104`	`};`
`104`	`105`
`105`	`106`	`private static void HandleError(int result)`
`@@ -215,7 +216,7 @@ public static void GitObjectIsNotNull(GitObject gitObject, string identifier)`
`215`	`216`	`}`
`216`	`217`	`else`
`217`	`218`	`{`
`218`		`- exceptionBuilder = m => new LibGit2SharpException(m);`
	`219`	`+ exceptionBuilder = m => new NotFoundException(m);`
`219`	`220`	`}`
`220`	`221`
`221`	`222`	`GitObjectIsNotNull(gitObject, identifier, exceptionBuilder);`