public void testRefsCacheAfterUpdate() { // Do not use the defalt repo for this case. IDictionary <string, Core.Ref> allRefs = db.getAllRefs(); ObjectId oldValue = db.Resolve("HEAD"); ObjectId newValue = db.Resolve("HEAD^"); // first make HEAD refer to loose ref RefUpdate updateRef = db.UpdateRef(Constants.HEAD); updateRef.IsForceUpdate = true; updateRef.NewObjectId = newValue; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); // now update that ref updateRef = db.UpdateRef(Constants.HEAD); updateRef.IsForceUpdate = true; updateRef.NewObjectId = oldValue; update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FAST_FORWARD, update); allRefs = db.getAllRefs(); Ref master = allRefs.GetValue("refs/heads/master"); Ref head = allRefs.GetValue("HEAD"); Assert.AreEqual("refs/heads/master", master.Name); Assert.AreEqual("HEAD", head.Name); Assert.IsTrue(head.isSymbolic(), "is symbolic reference"); Assert.AreSame(master, head.getTarget()); }
public void testNoCacheObjectIdSubclass() { string newRef = "refs/heads/abc"; RefUpdate ru = updateRef(newRef); RevCommit newid = new RevCommit(ru.getNewObjectId()) { // empty }; ru.setNewObjectId(newid); RefUpdate.RefUpdateResult update = ru.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update); Core.Ref r = db.getAllRefs()[newRef]; Assert.IsNotNull(r); Assert.AreEqual(newRef, r.Name); Assert.IsNotNull(r.ObjectId); Assert.AreNotSame(newid, r.ObjectId); Assert.AreSame(typeof(ObjectId), r.ObjectId.GetType()); Assert.AreEqual(newid.Copy(), r.ObjectId); IList <ReflogReader.Entry> reverseEntries1 = db.ReflogReader("refs/heads/abc").getReverseEntries(); ReflogReader.Entry entry1 = reverseEntries1[0]; Assert.AreEqual(1, reverseEntries1.Count); Assert.AreEqual(ObjectId.ZeroId, entry1.getOldId()); Assert.AreEqual(r.ObjectId, entry1.getNewId()); Assert.AreEqual(new PersonIdent(db).ToString(), entry1.getWho().ToString()); Assert.AreEqual("", entry1.getComment()); IList <ReflogReader.Entry> reverseEntries2 = db.ReflogReader("HEAD").getReverseEntries(); Assert.AreEqual(0, reverseEntries2.Count); }
public void testRenameRefNameColission1avoided() { // setup ObjectId rb = db.Resolve("refs/heads/b"); writeSymref(Constants.HEAD, "refs/heads/a"); RefUpdate updateRef = db.UpdateRef("refs/heads/a"); updateRef.NewObjectId = rb; updateRef.setRefLogMessage("Setup", false); Assert.AreEqual(RefUpdate.RefUpdateResult.FAST_FORWARD, updateRef.update()); ObjectId oldHead = db.Resolve(Constants.HEAD); Assert.IsTrue(rb.Equals(oldHead)); // assumption for this test writeReflog(db, rb, rb, "Just a message", "refs/heads/a"); Assert.IsTrue(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/a")).Exists, "internal check, we have a log"); // Now this is our test RefRename renameRef = db.RenameRef("refs/heads/a", "refs/heads/a/b"); RefUpdate.RefUpdateResult result = renameRef.rename(); Assert.AreEqual(RefUpdate.RefUpdateResult.RENAMED, result); Assert.IsNull(db.Resolve("refs/heads/a")); Assert.AreEqual(rb, db.Resolve("refs/heads/a/b")); Assert.AreEqual(3, db.ReflogReader("a/b").getReverseEntries().Count); Assert.AreEqual("Branch: renamed a to a/b", db.ReflogReader("a/b") .getReverseEntries()[0].getComment()); Assert.AreEqual("Just a message", db.ReflogReader("a/b") .getReverseEntries()[1].getComment()); Assert.AreEqual("Setup", db.ReflogReader("a/b").getReverseEntries() [2].getComment()); // same thing was logged to HEAD Assert.AreEqual("Branch: renamed a to a/b", db.ReflogReader("HEAD") .getReverseEntries()[0].getComment()); }
public void testNewNamespaceConflictWithLoosePrefixOfExisting() { string newRef = "refs/heads/z/a"; RefUpdate ru = updateRef(newRef); RevCommit newid = new RevCommit(ru.NewObjectId) { // empty }; ru.NewObjectId = newid; RefUpdate.RefUpdateResult update = ru.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update); // end setup string newRef2 = "refs/heads/z"; RefUpdate ru2 = updateRef(newRef2); RevCommit newid2 = new RevCommit(ru2.NewObjectId) { // empty }; ru.NewObjectId = newid2; RefUpdate.RefUpdateResult update2 = ru2.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.LOCK_FAILURE, update2); Assert.AreEqual(1, db.ReflogReader("refs/heads/z/a").getReverseEntries().Count); Assert.IsNull(db.ReflogReader("refs/heads/z")); Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count); }
public void testUpdateRefDetachedUnbornHead() { ObjectId ppid = db.Resolve("refs/heads/master^"); writeSymref("HEAD", "refs/heads/unborn"); RefUpdate updateRef = db.UpdateRef("HEAD", true); updateRef.IsForceUpdate = true; updateRef.NewObjectId = ppid; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update); Assert.AreEqual(ppid, db.Resolve("HEAD")); Ref @ref = db.getRef("HEAD"); Assert.AreEqual("HEAD", @ref.Name); Assert.IsTrue([email protected](), "is detached"); // the branch HEAD referred to is left untouched Assert.IsNull(db.Resolve("refs/heads/unborn")); ReflogReader reflogReader = new ReflogReader(db, "HEAD"); ReflogReader.Entry e = reflogReader.getReverseEntries()[0]; Assert.AreEqual(ObjectId.ZeroId, e.getOldId()); Assert.AreEqual(ppid, e.getNewId()); Assert.AreEqual("GIT_COMMITTER_EMAIL", e.getWho().EmailAddress); Assert.AreEqual("GIT_COMMITTER_NAME", e.getWho().Name); Assert.AreEqual(1250379778000L, e.getWho().When); }
public virtual void testReadAllIncludingSymrefs() { ObjectId masterId = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/remotes/origin/master"); updateRef.setNewObjectId(masterId); updateRef.setForceUpdate(true); updateRef.update(); writeSymref("refs/remotes/origin/HEAD", "refs/remotes/origin/master"); ObjectId r = db.Resolve("refs/remotes/origin/HEAD"); Assert.AreEqual(masterId, r); IDictionary <string, global::GitSharp.Core.Ref> allRefs = db.getAllRefs(); global::GitSharp.Core.Ref refHEAD = allRefs["refs/remotes/origin/HEAD"]; Assert.IsNotNull(refHEAD); Assert.AreEqual(masterId, refHEAD.ObjectId); Assert.IsFalse(refHEAD.IsPeeled); Assert.IsNull(refHEAD.PeeledObjectId); global::GitSharp.Core.Ref refmaster = allRefs["refs/remotes/origin/master"]; Assert.AreEqual(masterId, refmaster.ObjectId); Assert.IsFalse(refmaster.IsPeeled); Assert.IsNull(refmaster.PeeledObjectId); }
public void testLooseDelete() { string newRef = "refs/heads/abc"; RefUpdate @ref = updateRef(newRef); @ref.update(); // create loose ref @ref = updateRef(newRef); // refresh delete(@ref, RefUpdate.RefUpdateResult.NO_CHANGE); Assert.IsNull(db.ReflogReader("refs/heads/abc")); }
public void testUpdateRefNoChange() { ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.NewObjectId = pid; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.NO_CHANGE, update); Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public void testReadLooseRef() { RefUpdate updateRef = db.UpdateRef("ref/heads/new"); updateRef.setNewObjectId(db.Resolve("refs/heads/master")); RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update); global::GitSharp.Core.Ref @ref = db.getRef("ref/heads/new"); Assert.AreEqual(Storage.Loose, @ref.StorageFormat); }
public void testDeleteLoosePackedRejected() { ObjectId pid = db.Resolve("refs/heads/c^"); ObjectId oldpid = db.Resolve("refs/heads/c"); RefUpdate updateRef = db.UpdateRef("refs/heads/c"); updateRef.NewObjectId = pid; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.REJECTED, update); Assert.AreEqual(oldpid, db.Resolve("refs/heads/c")); }
public void testUpdateRefLockFailureWrongOldValue() { ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.NewObjectId = pid; updateRef.ExpectedOldObjectId = db.Resolve("refs/heads/master^"); RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.LOCK_FAILURE, update); Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public void testNewNamespaceConflictWithPackedPrefixOfExisting() { string newRef = "refs/heads/prefix"; RefUpdate ru = updateRef(newRef); RevCommit newid = new RevCommit(ru.NewObjectId) { // empty }; ru.NewObjectId = newid; RefUpdate.RefUpdateResult update = ru.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.LOCK_FAILURE, update); Assert.IsNull(db.ReflogReader("refs/heads/prefix")); Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count); }
public void testReadSimplePackedRefSameRepo() { global::GitSharp.Core.Ref @ref = db.getRef("refs/heads/master"); ObjectId pid = db.Resolve("refs/heads/master^"); Assert.AreEqual(Storage.Packed, @ref.StorageFormat); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.setNewObjectId(pid); updateRef.setForceUpdate(true); RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); @ref = db.getRef("refs/heads/master"); Assert.AreEqual(Storage.Loose, @ref.StorageFormat); }
public void testReadSymRefToLoosePacked() { ObjectId pid = db.Resolve("refs/heads/master^"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.setNewObjectId(pid); updateRef.setForceUpdate(true); RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); // internal writeSymref("HEAD", "refs/heads/master"); global::GitSharp.Core.Ref @ref = db.getRef("HEAD"); Assert.AreEqual(Storage.Loose, @ref.StorageFormat); @ref = @ref.getTarget(); Assert.AreEqual("refs/heads/master", @ref.Name); Assert.AreEqual(Storage.Loose, @ref.StorageFormat); }
public void testDeleteHEADreferencedRef() { ObjectId pid = db.Resolve("refs/heads/master^"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.NewObjectId = pid; updateRef.IsForceUpdate = true; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); // internal RefUpdate updateRef2 = db.UpdateRef("refs/heads/master"); RefUpdate.RefUpdateResult delete = updateRef2.delete(); Assert.AreEqual(RefUpdate.RefUpdateResult.REJECTED_CURRENT_BRANCH, delete); Assert.AreEqual(pid, db.Resolve("refs/heads/master")); Assert.AreEqual(1, db.ReflogReader("refs/heads/master").getReverseEntries().Count); Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count); }
public void testDeleteLoosePacked() { ObjectId pid = db.Resolve("refs/heads/c^"); RefUpdate updateRef = db.UpdateRef("refs/heads/c"); updateRef.NewObjectId = pid; updateRef.IsForceUpdate = true; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); // internal // The real test here RefUpdate updateRef2 = db.UpdateRef("refs/heads/c"); updateRef2.IsForceUpdate = true; RefUpdate.RefUpdateResult delete = updateRef2.delete(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, delete); Assert.IsNull(db.Resolve("refs/heads/c")); }
public void testUpdateRefForward() { ObjectId ppid = db.Resolve("refs/heads/master^"); ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.NewObjectId = ppid; updateRef.IsForceUpdate = true; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); Assert.AreEqual(ppid, db.Resolve("refs/heads/master")); // real test RefUpdate updateRef2 = db.UpdateRef("refs/heads/master"); updateRef2.NewObjectId = pid; RefUpdate.RefUpdateResult update2 = updateRef2.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FAST_FORWARD, update2); Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public void testRenameBranchAlsoInPack() { ObjectId rb = db.Resolve("refs/heads/b"); ObjectId rb2 = db.Resolve("refs/heads/b~1"); Assert.AreEqual(Storage.Packed, db.getRef("refs/heads/b").StorageFormat); RefUpdate updateRef = db.UpdateRef("refs/heads/b"); updateRef.NewObjectId = rb2; updateRef.IsForceUpdate = true; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update, "internal check new ref is loose"); Assert.AreEqual(Storage.Loose, db.getRef("refs/heads/b").StorageFormat); writeReflog(db, rb, rb, "Just a message", "refs/heads/b"); Assert.IsTrue(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/b")).Exists, "log on old branch"); RefRename renameRef = db.RenameRef("refs/heads/b", "refs/heads/new/name"); RefUpdate.RefUpdateResult result = renameRef.rename(); Assert.AreEqual(RefUpdate.RefUpdateResult.RENAMED, result); Assert.AreEqual(rb2, db.Resolve("refs/heads/new/name")); Assert.IsNull(db.Resolve("refs/heads/b")); Assert.AreEqual("Branch: renamed b to new/name", db.ReflogReader( "new/name").getLastEntry().getComment()); Assert.AreEqual(3, db.ReflogReader("refs/heads/new/name").getReverseEntries().Count); Assert.AreEqual("Branch: renamed b to new/name", db.ReflogReader("refs/heads/new/name").getReverseEntries()[0].getComment()); Assert.AreEqual(0, db.ReflogReader("HEAD").getReverseEntries().Count); // make sure b's log file is gone too. Assert.IsFalse(new FileInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/b")).Exists); // Create new Repository instance, to reread caches and make sure our // assumptions are persistent. using (Core.Repository ndb = new Core.Repository(db.Directory)) { Assert.AreEqual(rb2, ndb.Resolve("refs/heads/new/name")); Assert.IsNull(ndb.Resolve("refs/heads/b")); } }
public void testUpdateRefLockFailureLocked() { ObjectId opid = db.Resolve("refs/heads/master"); ObjectId pid = db.Resolve("refs/heads/master^"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.NewObjectId = pid; var lockFile1 = new LockFile(new FileInfo(Path.Combine(db.Directory.FullName, "refs/heads/master"))); try { Assert.IsTrue(lockFile1.Lock()); // precondition to test RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.LOCK_FAILURE, update); Assert.AreEqual(opid, db.Resolve("refs/heads/master")); var lockFile2 = new LockFile(new FileInfo(Path.Combine(db.Directory.FullName, "refs/heads/master"))); Assert.IsFalse(lockFile2.Lock()); // was locked, still is } finally { lockFile1.Unlock(); } }
public void testUpdateRefForwardWithCheck2() { ObjectId ppid = db.Resolve("refs/heads/master^"); ObjectId pid = db.Resolve("refs/heads/master"); RefUpdate updateRef = db.UpdateRef("refs/heads/master"); updateRef.NewObjectId = ppid; updateRef.IsForceUpdate = true; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, update); Assert.AreEqual(ppid, db.Resolve("refs/heads/master")); // real test RevCommit old = new Core.RevWalk.RevWalk(db).parseCommit(ppid); RefUpdate updateRef2 = db.UpdateRef("refs/heads/master"); updateRef2.ExpectedOldObjectId = old; updateRef2.NewObjectId = pid; RefUpdate.RefUpdateResult update2 = updateRef2.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.FAST_FORWARD, update2); Assert.AreEqual(pid, db.Resolve("refs/heads/master")); }
public void testDeleteLooseAndItsDirectory() { ObjectId pid = db.Resolve("refs/heads/c^"); RefUpdate updateRef = db.UpdateRef("refs/heads/z/c"); updateRef.NewObjectId = pid; updateRef.IsForceUpdate = true; updateRef.setRefLogMessage("new test ref", false); RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update); // internal Assert.IsTrue(new DirectoryInfo(Path.Combine(db.Directory.FullName, Constants.R_HEADS + "z")).Exists); Assert.IsTrue(new DirectoryInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/z")).Exists); // The real test here RefUpdate updateRef2 = db.UpdateRef("refs/heads/z/c"); updateRef2.IsForceUpdate = true; RefUpdate.RefUpdateResult delete = updateRef2.delete(); Assert.AreEqual(RefUpdate.RefUpdateResult.FORCED, delete); Assert.IsNull(db.Resolve("refs/heads/z/c")); Assert.IsFalse(new DirectoryInfo(Path.Combine(db.Directory.FullName, Constants.R_HEADS + "z")).Exists); Assert.IsFalse(new DirectoryInfo(Path.Combine(db.Directory.FullName, "logs/refs/heads/z")).Exists); }
public void testRefsCacheAfterUpdateLooseOnly() { // Do not use the defalt repo for this case. IDictionary <string, Core.Ref> allRefs = db.getAllRefs(); ObjectId oldValue = db.Resolve("HEAD"); writeSymref(Constants.HEAD, "refs/heads/newref"); RefUpdate updateRef = db.UpdateRef(Constants.HEAD); updateRef.IsForceUpdate = true; updateRef.NewObjectId = oldValue; RefUpdate.RefUpdateResult update = updateRef.update(); Assert.AreEqual(RefUpdate.RefUpdateResult.NEW, update); allRefs = db.getAllRefs(); Ref head = allRefs.GetValue("HEAD"); Ref newref = allRefs.GetValue("refs/heads/newref"); Assert.AreEqual("refs/heads/newref", newref.Name); Assert.AreEqual("HEAD", head.Name); Assert.IsTrue(head.isSymbolic(), "is symbolic reference"); Assert.AreSame(newref, head.getTarget()); }
private void Execute(ReceiveCommand cmd) { try { RefUpdate ru = db.UpdateRef(cmd.getRefName()); ru.setRefLogIdent(getRefLogIdent()); switch (cmd.getType()) { case ReceiveCommand.Type.DELETE: if (!ObjectId.ZeroId.Equals(cmd.getOldId())) { // We can only do a CAS style delete if the client // didn't bork its delete request by sending the // wrong zero id rather than the advertised one. // ru.setExpectedOldObjectId(cmd.getOldId()); } ru.setForceUpdate(true); Status(cmd, ru.delete(walk)); break; case ReceiveCommand.Type.CREATE: case ReceiveCommand.Type.UPDATE: case ReceiveCommand.Type.UPDATE_NONFASTFORWARD: ru.setForceUpdate(isAllowNonFastForwards()); ru.setExpectedOldObjectId(cmd.getOldId()); ru.setNewObjectId(cmd.getNewId()); ru.setRefLogMessage("push", true); Status(cmd, ru.update(walk)); break; } } catch (IOException err) { cmd.setResult(ReceiveCommand.Result.REJECTED_OTHER_REASON, "lock error: " + err.Message); } }
public void Update(RevWalk.RevWalk walk) { update.update(walk); }